source: trunk/src/fortran/RpUnitsFInterface.cc @ 97

Last change on this file since 97 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: 6.1 KB
Line 
1/*
2 * ----------------------------------------------------------------------
3 *  INTERFACE: Fortran Rappture Units 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 "RpUnits.h"
13#include "string.h"
14#include "RpUnitsFInterface.h"
15#include "RpUnitsFStubs.c"
16#include "RpBindingsDict.h"
17
18int
19rp_define_unit( char* unitName,
20                    int* basisName,
21                    int unitName_len    ) {
22
23    int result = -1;
24    RpUnits* newUnit = NULL;
25    RpUnits* basis = NULL;
26    std::string basisStrName = "";
27    std::string newUnitName = "";
28    char* inText = NULL;
29
30    inText = null_terminate(unitName,unitName_len);
31
32    if (basisName && *basisName) {
33        // basisStrName = fortObjDictUnits.find(*basisName);
34        basisStrName = ObjDictUnits.find(*basisName);
35
36        if (basisStrName != "") {
37            basis = RpUnits::find(basisStrName);
38        }
39    }
40
41    // newUnit = RpUnits::define(unitName, basis);
42    newUnit = RpUnits::define(inText, basis);
43
44    if (newUnit) {
45        result = storeObject_UnitsStr(newUnit->getUnitsName());
46    }
47
48    if (inText) {
49        free(inText);
50    }
51
52    return result;
53}
54
55
56int
57rp_find(char* searchName, int searchName_len)
58{
59
60    int result = -1;
61    char* inText = NULL;
62
63    inText = null_terminate(searchName,searchName_len);
64
65    // RpUnits* searchUnit = RpUnits::find(searchName);
66    RpUnits* searchUnit = RpUnits::find(inText);
67
68    if (searchUnit) {
69        result = storeObject_UnitsStr(searchUnit->getUnitsName());
70    }
71
72    if (inText) {
73        free(inText);
74    }
75
76    return result;
77}
78
79int
80rp_make_metric(int* basis)
81{
82    int result = -1;
83    RpUnits* newBasis = NULL;
84
85    if (basis && *basis) {
86        newBasis = getObject_UnitsStr(*basis);
87
88        if (newBasis) {
89            result = RpUnits::makeMetric(newBasis);
90        }
91    }
92
93    return result;
94}
95
96int
97rp_get_units(int* unitRefVal, char* retText, int retText_len)
98{
99    RpUnits* unitObj = NULL;
100    std::string unitNameText = "";
101    int result = 0;
102
103    if (unitRefVal && *unitRefVal) {
104        unitObj = getObject_UnitsStr(*unitRefVal);
105        if (unitObj) {
106            unitNameText = unitObj->getUnits();
107            fortranify(unitNameText.c_str(), retText, retText_len);
108        }
109    }
110
111    return result;
112}
113
114int
115rp_get_units_name(int* unitRefVal, char* retText, int retText_len)
116{
117    RpUnits* unitObj = NULL;
118    std::string unitNameText = "";
119    int result = 0;
120
121    if (unitRefVal && *unitRefVal) {
122        unitObj = getObject_UnitsStr(*unitRefVal);
123        if (unitObj) {
124            unitNameText = unitObj->getUnitsName();
125            fortranify(unitNameText.c_str(), retText, retText_len);
126        }
127    }
128
129    return result;
130}
131
132int
133rp_get_exponent(int* unitRefVal, double* retExponent)
134{
135    RpUnits* unitObj = NULL;
136    int result = 0;
137
138    if (unitRefVal && *unitRefVal) {
139        unitObj = getObject_UnitsStr(*unitRefVal);
140        if (unitObj) {
141            *retExponent = unitObj->getExponent();
142        }
143    }
144
145    return result;
146}
147
148int
149rp_get_basis(int* unitRefVal)
150{
151    RpUnits* unitObj = NULL;
152    RpUnits* basisObj = NULL;
153    int result = -1;
154
155    if (unitRefVal && *unitRefVal) {
156        unitObj = getObject_UnitsStr(*unitRefVal);
157
158        if (unitObj) {
159            basisObj = unitObj->getBasis();
160
161            if (basisObj) {
162                result = storeObject_UnitsStr(basisObj->getUnitsName());
163            }
164        }
165    }
166
167    return result;
168}
169
170int
171rp_units_convert_dbl (  char* fromVal,
172                            char* toUnitsName,
173                            double* convResult,
174                            int fromVal_len,
175                            int toUnitsName_len ) {
176
177    char* inFromVal = NULL;
178    char* inToUnitsName = NULL;
179    int result = -1;
180    int showUnits = 0;
181    std::string convStr = "";
182
183    // prepare string for c
184    inFromVal = null_terminate(fromVal,fromVal_len);
185    inToUnitsName = null_terminate(toUnitsName,toUnitsName_len);
186
187    if (inFromVal && inToUnitsName) {
188        // the call to RpUnits::convert() populates the result flag
189        convStr = RpUnits::convert(inFromVal,inToUnitsName,showUnits,&result);
190
191        if (!convStr.empty()) {
192            *convResult = atof(convStr.c_str());
193        }
194    }
195
196    // clean up memory
197    if (inFromVal) {
198        free(inFromVal);
199        inFromVal = NULL;
200    }
201
202    if (inToUnitsName) {
203        free(inToUnitsName);
204        inToUnitsName = NULL;
205    }
206
207    return result;
208}
209
210int
211rp_units_convert_str (      char* fromVal,
212                                char* toUnitsName,
213                                char* retText,
214                                int fromVal_len,
215                                int toUnitsName_len,
216                                int retText_len     ) {
217
218    char* inFromVal = NULL;
219    char* inToUnitsName = NULL;
220    std::string convStr = "";
221    int showUnits = 1;
222    int result = -1;
223
224    // prepare string for c
225    inFromVal = null_terminate(fromVal,fromVal_len);
226    inToUnitsName = null_terminate(toUnitsName,toUnitsName_len);
227
228    if (inFromVal && inToUnitsName) {
229
230        // do the conversion
231        convStr = RpUnits::convert(inFromVal,inToUnitsName,showUnits,&result);
232
233        if (!convStr.empty()) {
234            // prepare string for fortran
235            fortranify(convStr.c_str(), retText, retText_len);
236        }
237    }
238
239    // clean up out memory
240    if (inFromVal) {
241        free(inFromVal);
242        inFromVal = NULL;
243    }
244
245    if (inToUnitsName) {
246        free(inToUnitsName);
247        inToUnitsName = NULL;
248    }
249
250    // return the same result from the RpUnits::convert call.
251    return result;
252}
253
254int
255rp_units_add_presets ( char* presetName, int presetName_len) {
256
257    char* inPresetName = NULL;
258    int result = -1;
259
260    inPresetName = null_terminate(presetName,presetName_len);
261
262    result = RpUnits::addPresets(inPresetName);
263
264    if (inPresetName) {
265        free(inPresetName);
266        inPresetName = NULL;
267    }
268
269    return result;
270}
271
Note: See TracBrowser for help on using the repository browser.