1 krisbash 1.1 #include "/usr/include/python2.6/Python.h"
2 #include "structmember.h"
3 #include "MI.h"
4 #include <stdlib.h>
5 #include "datetime.h"
6
7 static PyObject *MIError;
8
9 /*Defines a PMI_Instance Type Object which is a Python Object that contains a reference to an intance of MI_Instance */
10 typedef struct{
11 PyObject_HEAD
12 MI_Instance *miInstance;
13 PyObject *propertyValues;
14 PyObject *propertyTypes;
15 PyObject *propertyFlags;
16 } PMI_Instance;
17
18
19 static void PMI_Instance_dealloc(PMI_Instance *self)
20 {
21 MI_Result miResult = MI_RESULT_OK;
22 krisbash 1.1 miResult = MI_Instance_Delete(self->miInstance);
23
24 Py_CLEAR(self->propertyValues);
25 Py_CLEAR(self->propertyTypes);
26 Py_CLEAR(self->propertyFlags);
27 self->ob_type->tp_free((PyObject*) self);
28
29 }
30
31 static PyObject* PMI_Instance_new(PyTypeObject *type)
32 {
33 PMI_Instance *self;
34 self = (PMI_Instance *)type->tp_alloc(type,0);
35 if(self != NULL){
36 self-> miInstance = NULL;
37 self-> propertyValues = NULL;
38 self-> propertyTypes = NULL;
39 self-> propertyFlags = NULL;
40 }
41 return (PyObject *)self;
42 }
43 krisbash 1.1
44 static PyTypeObject PMI_InstanceType ;
45
46 static PyObject* initPMI()
47 {
48 PyObject *instance = PyObject_CallObject((PyObject*) &PMI_InstanceType, NULL);
49 Py_INCREF(instance);
50 return instance;
51 }
52
53 static PyObject* MakePropertyDict(PMI_Instance *pmiInstance);
54
55 static PyObject* Get_Element_Value(const MI_Value *elementValue, MI_Type elementType)
56
57 {
58 MI_Type nonArrayType = (MI_Type) (elementType & (~MI_ARRAY));
59 switch (elementType)
60 {
61 case MI_BOOLEAN:
62 {
63 if(elementValue->boolean)
64 krisbash 1.1 return Py_True;
65 return Py_False;
66 }
67
68 case MI_SINT8:
69 {
70 return Py_BuildValue("b",elementValue->sint8);
71 }
72
73 case MI_UINT8:
74 {
75 return Py_BuildValue("B",elementValue->uint8);
76 }
77
78 case MI_SINT16:
79 {
80 return Py_BuildValue("h",elementValue->sint16);
81 }
82
83 case MI_UINT16:
84 {
85 krisbash 1.1 return Py_BuildValue("H",elementValue->uint16);
86 }
87
88 case MI_SINT32:
89 {
90 return Py_BuildValue("i",elementValue->sint32);
91 }
92
93 case MI_UINT32:
94 {
95 return Py_BuildValue("I",elementValue->uint32);
96 }
97
98 case MI_SINT64:
99 {
100 return Py_BuildValue("L",elementValue->sint64);
101 }
102
103 case MI_UINT64:
104 {
105 return Py_BuildValue("K",elementValue->uint64);
106 krisbash 1.1 }
107
108 case MI_REAL32:
109 {
110 return Py_BuildValue("f",elementValue->real32);
111 }
112
113 case MI_REAL64:
114 {
115 return Py_BuildValue("d",elementValue->real64);
116 }
117
118 case MI_CHAR16:
119 {
120 return Py_BuildValue("H",elementValue->char16);
121 }
122
123 case MI_DATETIME:
124 {
125 const MI_Datetime* x = &elementValue->datetime;
126
127 krisbash 1.1 if(x->isTimestamp)
128 {
129 //MI_Sint32 utc = x->u.timestamp.utc;
130 PyObject* datetimeObject = PyDateTime_FromDateAndTime(x->u.timestamp.year,x->u.timestamp.month,x->u.timestamp.day,x->u.timestamp.hour,x->u.timestamp.minute,x->u.timestamp.second,x->u.timestamp.microseconds);
131 return datetimeObject;
132 }
133 else
134 {
135 //Convert MI_Datetime object to PyDatetime object with only day, hour and second attributes
136 int hours = x->u.interval.hours;
137 int minutes = x->u.interval.minutes;
138 int seconds = x->u.interval.seconds;
139 PyObject* delta = PyDelta_FromDSU(x->u.interval.days,hours*24+minutes*60+seconds,x->u.interval.microseconds);
140 return delta;
141 }
142 }
143
144 case MI_STRING:
145 {
146 return Py_BuildValue("s",elementValue->string);
147 }
148 krisbash 1.1
149 case MI_BOOLEANA:
150 {
151 MI_Uint32 i;
152 PyObject* valueSets = PyTuple_New(elementValue->booleana.size);
153
154 for (i = 0; i < elementValue->booleana.size; i++)
155 {
156 MI_Value value;
157 value.boolean = elementValue->booleana.data[i];
158 PyObject* propertyValue= Get_Element_Value(&value, nonArrayType);
159 PyTuple_SetItem(valueSets,i,propertyValue);
160 }
161 return valueSets;
162 }
163
164 case MI_SINT8A:
165 {
166 MI_Uint32 i;
167 PyObject* valueSets = PyTuple_New(elementValue->sint8a.size);
168 for (i = 0; i < elementValue->sint8a.size; i++)
169 krisbash 1.1 {
170 MI_Value value;
171 value.sint8 = elementValue->sint8a.data[i];
172 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
173 PyTuple_SetItem(valueSets,i,propertyValue);
174 }
175 return valueSets;
176 }
177
178 case MI_UINT8A:
179 {
180 MI_Uint32 i;
181 PyObject* valueSets = PyTuple_New(elementValue->uint8a.size);
182 for (i = 0; i < elementValue->uint8a.size; i++)
183 {
184 MI_Value value;
185 value.uint8 = elementValue->uint8a.data[i];
186 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
187 PyTuple_SetItem(valueSets,i,propertyValue);
188 }
189 return valueSets;
190 krisbash 1.1 }
191
192 case MI_SINT16A:
193 {
194 MI_Uint32 i;
195 PyObject* valueSets = PyTuple_New(elementValue->sint16a.size);
196 for (i = 0; i < elementValue->sint16a.size; i++)
197 {
198 MI_Value value;
199 value.sint16 = elementValue->sint16a.data[i];
200 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
201 PyTuple_SetItem(valueSets,i,propertyValue);
202 }
203 return valueSets;
204 }
205
206 case MI_UINT16A:
207 {
208 MI_Uint32 i;
209 PyObject* valueSets = PyTuple_New(elementValue->uint16a.size);
210 for (i = 0; i < elementValue->uint16a.size; i++)
211 krisbash 1.1 {
212 MI_Value value;
213 value.uint16 = elementValue->uint16a.data[i];
214 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
215 PyTuple_SetItem(valueSets,i,propertyValue);
216 }
217 return valueSets;
218 }
219
220 case MI_SINT32A:
221 {
222 MI_Uint32 i;
223 PyObject* valueSets = PyTuple_New(elementValue->sint32a.size);
224 for (i = 0; i < elementValue->sint32a.size; i++)
225 {
226 MI_Value value;
227 value.sint32 = elementValue->sint32a.data[i];
228 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
229 PyTuple_SetItem(valueSets,i,propertyValue);
230 }
231 return valueSets;
232 krisbash 1.1 }
233
234 case MI_UINT32A:
235 {
236 MI_Uint32 i;
237 PyObject* valueSets = PyTuple_New(elementValue->uint32a.size);
238 for (i = 0; i < elementValue->uint32a.size; i++)
239 {
240 MI_Value value;
241 value.uint32 = elementValue->uint32a.data[i];
242 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
243 PyTuple_SetItem(valueSets,i,propertyValue);
244 }
245 return valueSets;
246 }
247
248 case MI_SINT64A:
249 {
250 MI_Uint32 i;
251 PyObject* valueSets = PyTuple_New(elementValue->sint64a.size);
252 for (i = 0; i < elementValue->sint64a.size; i++)
253 krisbash 1.1 {
254 MI_Value value;
255 value.sint64 = elementValue->sint64a.data[i];
256 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
257 PyTuple_SetItem(valueSets,i,propertyValue);
258 }
259 return valueSets;
260 }
261
262 case MI_UINT64A:
263 {
264 MI_Uint32 i;
265 PyObject* valueSets = PyTuple_New(elementValue->uint64a.size);
266 for (i = 0; i < elementValue->uint64a.size; i++)
267 {
268 MI_Value value;
269 value.uint64 = elementValue->uint64a.data[i];
270 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
271 PyTuple_SetItem(valueSets,i,propertyValue);
272 }
273 return valueSets;
274 krisbash 1.1 }
275
276 case MI_REAL32A:
277 {
278 MI_Uint32 i;
279 PyObject* valueSets = PyTuple_New(elementValue->real32a.size);
280 for (i = 0; i < elementValue->real32a.size; i++)
281 {
282 MI_Value value;
283 value.real32 = elementValue->real32a.data[i];
284 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
285 PyTuple_SetItem(valueSets,i,propertyValue);
286 }
287 return valueSets;
288 }
289
290 case MI_REAL64A:
291 {
292 MI_Uint32 i;
293 PyObject* valueSets = PyTuple_New(elementValue->real64a.size);
294 for (i = 0; i < elementValue->real64a.size; i++)
295 krisbash 1.1 {
296 MI_Value value;
297 value.real64 = elementValue->real64a.data[i];
298 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
299 PyTuple_SetItem(valueSets,i,propertyValue);
300 }
301 return valueSets;
302 }
303
304 case MI_CHAR16A:
305 {
306 MI_Uint32 i;
307 PyObject* valueSets = PyTuple_New(elementValue->char16a.size);
308 for (i = 0; i < elementValue->char16a.size; i++)
309 {
310 MI_Value value;
311 value.char16 = elementValue->char16a.data[i];
312 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
313 PyTuple_SetItem(valueSets,i,propertyValue);
314 }
315 return valueSets;
316 krisbash 1.1 }
317
318 case MI_DATETIMEA:
319 {
320 MI_Uint32 i;
321 PyObject* valueSets = PyTuple_New(elementValue->datetimea.size);
322 for (i = 0; i < elementValue->datetimea.size; i++)
323 {
324 MI_Value value;
325 value.datetime = elementValue->datetimea.data[i];
326 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
327 PyTuple_SetItem(valueSets,i,propertyValue);
328 }
329 return valueSets;
330 }
331
332 case MI_STRINGA:
333 {
334 MI_Uint32 i;
335 PyObject* valueSets = PyTuple_New(elementValue->stringa.size);
336 for (i = 0; i < elementValue->stringa.size; i++)
337 krisbash 1.1 {
338 MI_Value value;
339 value.string = elementValue->stringa.data[i];
340 PyObject* propertyValue = Get_Element_Value(&value, nonArrayType);
341 PyTuple_SetItem(valueSets,i,propertyValue);
342 }
343 return valueSets;
344 }
345
346 case MI_INSTANCE:
347 {
348 MI_Instance* inst = elementValue->instance;
349 PMI_Instance* embedded = (PMI_Instance*) initPMI();
350 embedded-> miInstance = inst;
351 if(inst!=NULL)
352 {
353 MakePropertyDict(embedded);
354 }
355 return (PyObject *)embedded;
356 }
357
358 krisbash 1.1 case MI_REFERENCE:
359 {
360 MI_Instance* inst = elementValue->reference;
361 PMI_Instance* embedded = (PMI_Instance*) initPMI();
362 embedded-> miInstance = inst;
363 if(inst!=NULL)
364 {
365 MakePropertyDict(embedded);
366 }
367 return (PyObject *)embedded;
368 }
369
370 case MI_INSTANCEA:
371 case MI_REFERENCEA:
372 {
373 const MI_InstanceA* inst = &elementValue->instancea;
374 MI_Uint32 i;
375 PyObject* valueSets = PyTuple_New(inst->size);
376 for (i = 0; i< inst->size; i++)
377 {
378 PMI_Instance* embedded = (PMI_Instance*) initPMI();
379 krisbash 1.1 if(inst->data[i]!=NULL)
380 {
381 embedded-> miInstance = inst->data[i];
382 MakePropertyDict(embedded);
383 PyTuple_SetItem(valueSets,i,(PyObject *)embedded);
384 }
385 else
386 {
387 PyTuple_SetItem(valueSets,i,Py_None);
388 }
389 }
390 return valueSets;
391 }
392
393 default:
394 Py_INCREF(Py_None);
395 return Py_None;
396 }
397
398 }
399
400 krisbash 1.1
401 static PyObject* MakePropertyDict(PMI_Instance *pmiInstance)
402 {
403 MI_Uint32 elementCount;
404 MI_Result miResult;
405 MI_Uint32 elementIndex;
406 const MI_Instance *miInstance = pmiInstance->miInstance;
407 if(miInstance == NULL)
408 {
409 PyErr_SetString(MIError,"MI_Instance is not valid");
410 return NULL;
411 }
412
413 miResult = MI_Instance_GetElementCount(miInstance, &elementCount);
414 if(miResult != MI_RESULT_OK)
415 {
416 PyErr_SetString(MIError,"MI_Instance_GetElement failed");
417 return NULL;
418 }
419
420 /*make a property dictionary containing property name and value pairs. */
421 krisbash 1.1 PyObject *propertyValues = PyDict_New();
422 PyObject *propertyTypes = PyDict_New();
423 PyObject *propertyFlags = PyDict_New();
424
425
426 const MI_Char *nameSpace;
427 miResult = MI_Instance_GetNameSpace(miInstance,&nameSpace);
428 if(miResult != MI_RESULT_OK)
429 {
430 PyErr_SetString(MIError,"MI_Instance_GetNameSpace failed");
431 return NULL;
432 }
433 PyObject *nameSpaceValue = Py_BuildValue("s",nameSpace);
434 PyDict_SetItemString(propertyValues,"nameSpace",nameSpaceValue);
435 PyDict_SetItemString(propertyTypes,"nameSpace",Py_BuildValue("i",13));
436
437
438 const MI_Char *classDecl;
439 miResult = MI_Instance_GetClassName(miInstance,&classDecl);
440 if(miResult != MI_RESULT_OK)
441 {
442 krisbash 1.1 PyErr_SetString(MIError,"MI_Instance_GetClassName failed");
443 return NULL;
444 }
445 PyObject *classDeclValue = Py_BuildValue("s",classDecl);
446 PyDict_SetItemString(propertyValues,"classDecl",classDeclValue);
447 PyDict_SetItemString(propertyTypes,"classDecl",Py_BuildValue("i",13));
448
449 for(elementIndex = 0; elementIndex < elementCount; elementIndex++)
450 {
451 const MI_Char *key;
452 MI_Value elementValue;
453 MI_Type elementType;
454 MI_Uint32 elementFlags;
455
456 miResult = MI_Instance_GetElementAt(miInstance,elementIndex,&key,&elementValue,&elementType,&elementFlags);
457 if(miResult != MI_RESULT_OK)
458 {
459 PyErr_SetString(MIError,"MI_Instance_GetElement failed");
460 return NULL;
461 }
462
463 krisbash 1.1 PyObject *value = Get_Element_Value(&elementValue,elementType);
464 if(PyDict_SetItemString(propertyValues,key,value))
465 {
466 PyErr_SetString(MIError,"Property dictionary insert item failed");
467 return NULL;
468 }
469 PyObject *typeValue = PyInt_FromLong(elementType);
470 //PyObject *flagValue = PyInt_FromLong(elementFlags); //Are we going to return the dictionary of pair <name,flag> ?
471 if(PyDict_SetItemString(propertyTypes,key,typeValue))
472 {
473 PyErr_SetString(MIError,"Property type dictionary insert item failed");
474 return NULL;
475 }
476 PyObject *flag = Py_BuildValue("s","");
477 if(elementFlags & MI_FLAG_KEY)
478 {
479 flag = Py_BuildValue("s","MI_FLAG_KEY");
480 }
481 if(PyDict_SetItemString(propertyFlags,key,flag))
482 {
483 PyErr_SetString(MIError,"Property flag dictionary insert item failed");
484 krisbash 1.1 return NULL;
485 }
486 }
487
488 pmiInstance->propertyValues = propertyValues;
489 pmiInstance->propertyTypes = propertyTypes;
490 pmiInstance->propertyFlags = propertyFlags;
491 Py_INCREF(Py_None);
492 return Py_None;
493 }
494
495
496 void SetPropertyValues(MI_Type elementType, PyObject *propertyValue, MI_Value *miValue)
497 {
498 MI_Value value;
499 switch (elementType)
500 {
501 case MI_BOOLEAN:
502 {
503 MI_Boolean booleanValue = propertyValue == Py_True? MI_TRUE:MI_FALSE;
504 value.boolean = booleanValue;
505 krisbash 1.1 *miValue = value;
506 break;
507 }
508 case MI_SINT8:
509 {
510 MI_Sint8 sint8Value = PyInt_AsLong(propertyValue);
511 value.sint8 = sint8Value;
512 *miValue = value;
513 break;
514 }
515 case MI_UINT8:
516 {
517 MI_Uint8 uint8Value = PyInt_AsLong(propertyValue);
518 value.uint8 = uint8Value;
519 *miValue = value;
520 break;
521 }
522 case MI_SINT16:
523 {
524 MI_Sint16 sint16Value = PyInt_AsLong(propertyValue);
525 value.sint16 = sint16Value;
526 krisbash 1.1 *miValue = value;
527 break;
528 }
529 case MI_UINT16:
530 {
531 MI_Uint16 uint16Value = PyInt_AsLong(propertyValue);
532 value.uint16 = uint16Value;
533 *miValue = value;
534 break;
535 }
536 case MI_SINT32:
537 {
538 MI_Sint32 sint32Value = PyInt_AsLong(propertyValue);
539 value.sint32 = sint32Value;
540 *miValue = value;
541 break;
542 }
543 case MI_UINT32:
544 {
545 MI_Uint32 uint32Value = PyInt_AsLong(propertyValue);
546 value.uint32 = uint32Value;
547 krisbash 1.1 *miValue = value;
548 break;
549 }
550 case MI_SINT64:
551 {
552 MI_Sint64 sint64Value = PyLong_AsLong(propertyValue);
553 value.sint64 = sint64Value;
554 *miValue = value;
555 break;
556 }
557 case MI_UINT64:
558 {
559 MI_Uint64 uint64Value = PyLong_AsUnsignedLong(propertyValue);
560 value.uint64 = uint64Value;
561 *miValue = value;
562 break;
563 }
564 case MI_REAL32:
565 {
566 MI_Real32 real32Value = PyFloat_AsDouble(propertyValue);
567 value.real32 = real32Value;
568 krisbash 1.1 *miValue = value;
569 break;
570 }
571 case MI_REAL64:
572 {
573 MI_Real64 real64Value = PyFloat_AsDouble(propertyValue);
574 value.real64 = real64Value;
575 *miValue = value;
576 break;
577 }
578 case MI_CHAR16:
579 {
580 MI_Char16 char16Value = PyInt_AsLong(propertyValue);
581 value.char16 = char16Value;
582 *miValue = value;
583 break;
584 }
585 case MI_STRING:
586 {
587 char *stringValue = PyString_AsString(propertyValue);
588 value.string = stringValue;
589 krisbash 1.1 *miValue = value;
590 break;
591 }
592
593 case MI_DATETIME:
594 {
595 /*Check whether the input python object is of type DateTime or TimeDelta */
596 if(PyDateTime_Check(propertyValue))
597 {
598 MI_Datetime dateTime;
599 MI_Timestamp timeStamp;
600 dateTime.isTimestamp = 1;
601 int year = PyDateTime_GET_YEAR(propertyValue);
602 int month = PyDateTime_GET_MONTH(propertyValue);
603 int day = PyDateTime_GET_DAY(propertyValue);
604 int hour = PyDateTime_DATE_GET_HOUR(propertyValue);
605 int minute = PyDateTime_DATE_GET_MINUTE(propertyValue);
606 int second = PyDateTime_DATE_GET_SECOND(propertyValue);
607 int microseconds = PyDateTime_DATE_GET_MICROSECOND(propertyValue);
608 timeStamp.year = year;
609 timeStamp.month = month;
610 krisbash 1.1 timeStamp.day = day;
611 timeStamp.hour = hour;
612 timeStamp.minute = minute;
613 timeStamp.second = second;
614 timeStamp.microseconds = microseconds;
615 //if timezone not specified, set the default to UTC time
616 timeStamp.utc = 5;
617 dateTime.u.timestamp = timeStamp;
618 value.datetime = dateTime;
619 *miValue = value;
620 }
621 /* no equivalent way of doing conversions. pydatetime object does not have days */
622 else
623 {
624 MI_Datetime dateTime;
625 dateTime.isTimestamp = 0;
626 MI_Interval interval;
627 int days = PyDateTime_GET_DAY(propertyValue);
628 int seconds = PyDateTime_DATE_GET_SECOND(propertyValue);
629 int hours = (int)seconds/60/60;
630 int minutes = (seconds-hours*60*60)/60;
631 krisbash 1.1 seconds = seconds - hours*60*60 - minutes *60;
632 int microseconds = PyDateTime_DATE_GET_MICROSECOND(propertyValue);
633 interval.days = days;
634 interval.hours = hours;
635 interval.minutes = minutes;
636 interval.seconds = seconds;
637 interval.microseconds = microseconds;
638 interval.__padding1 = 0;
639 interval.__padding2 = 0;
640 interval.__padding3 = 0;
641 dateTime.u.interval = interval;
642 value.datetime = dateTime;
643 *miValue = value;
644 }
645 break;
646 }
647 case MI_BOOLEANA:
648 {
649 Py_ssize_t size = PyList_Size(propertyValue);
650 MI_BooleanA miBooleanA;
651 miBooleanA.size = size;
652 krisbash 1.1 int i;
653 MI_Boolean booleanA[size];
654 for (i = 0; i < size; i++)
655 {
656 PyObject* boolean = PyList_GetItem(propertyValue,i);
657 if(boolean == Py_False)
658 {
659 booleanA[i] = MI_FALSE;
660 }
661 else
662 {
663 booleanA[i] = MI_TRUE;
664 }
665 }
666 miBooleanA.data = booleanA;
667 value.booleana = miBooleanA;
668 *miValue = value;
669 break;
670 }
671 case MI_UINT8A:
672 {
673 krisbash 1.1 Py_ssize_t size = PyList_Size(propertyValue);
674 MI_Uint8A miUint8A;
675 miUint8A.size = size;
676 int i;
677 MI_Uint8 uint8A[size];
678 for (i = 0; i < size; i++)
679 {
680 PyObject *value = PyList_GetItem(propertyValue,i);
681 uint8A[i] = PyInt_AsLong(value);
682 }
683 miUint8A.data = uint8A;
684 value.uint8a = miUint8A;
685 *miValue = value;
686 break;
687 }
688 case MI_SINT8A:
689 {
690 Py_ssize_t size = PyList_Size(propertyValue);
691 MI_Sint8A miSint8A;
692 miSint8A.size = size;
693 int i;
694 krisbash 1.1 MI_Sint8 sint8A[size];
695 for (i = 0; i < size; i++)
696 {
697 PyObject *value = PyList_GetItem(propertyValue,i);
698 sint8A[i] = PyInt_AsLong(value);
699 }
700 miSint8A.data = sint8A;
701 value.sint8a = miSint8A;
702 *miValue = value;
703 break;
704 }
705 case MI_UINT16A:
706 {
707 Py_ssize_t size = PyList_Size(propertyValue);
708 MI_Uint16A miUint16A;
709 miUint16A.size = size;
710 int i;
711 MI_Uint16 uint16A[size];
712 for (i = 0; i < size; i++)
713 {
714 PyObject *value = PyList_GetItem(propertyValue,i);
715 krisbash 1.1 uint16A[i] = PyInt_AsLong(value);
716 }
717 miUint16A.data = uint16A;
718 value.uint16a = miUint16A;
719 *miValue = value;
720 break;
721 }
722 case MI_SINT16A:
723 {
724 Py_ssize_t size = PyList_Size(propertyValue);
725 MI_Sint16A miSint16A;
726 miSint16A.size = size;
727 int i;
728 MI_Sint16 sint16A[size];
729 for (i = 0; i < size; i++)
730 {
731 PyObject *value = PyList_GetItem(propertyValue,i);
732 sint16A[i] = PyInt_AsLong(value);
733 }
734 miSint16A.data = sint16A;
735 value.sint16a = miSint16A;
736 krisbash 1.1 *miValue = value;
737 break;
738 }
739 case MI_UINT32A:
740 {
741 Py_ssize_t size = PyList_Size(propertyValue);
742 MI_Uint32A miUint32A;
743 miUint32A.size = size;
744 int i;
745 MI_Uint32 uint32A[size];
746 for (i = 0; i < size; i++)
747 {
748 PyObject *value = PyList_GetItem(propertyValue,i);
749 uint32A[i] = PyLong_AsLong(value);
750 }
751 miUint32A.data = uint32A;
752 value.uint32a = miUint32A;
753 *miValue = value;
754 break;
755 }
756 case MI_SINT32A:
757 krisbash 1.1 {
758 Py_ssize_t size = PyList_Size(propertyValue);
759 MI_Sint32A miSint32A;
760 miSint32A.size = size;
761 int i;
762 MI_Sint32 sint32A[size];
763 for (i = 0; i < size; i++)
764 {
765 PyObject *value = PyList_GetItem(propertyValue,i);
766 sint32A[i] = PyLong_AsLong(value);
767 }
768 miSint32A.data = sint32A;
769 value.sint32a = miSint32A;
770 *miValue = value;
771 break;
772 }
773 case MI_UINT64A:
774 {
775 Py_ssize_t size = PyList_Size(propertyValue);
776 MI_Uint64A miUint64A;
777 miUint64A.size = size;
778 krisbash 1.1 int i;
779 MI_Uint64 uint64A[size];
780 for (i = 0; i < size; i++)
781 {
782 PyObject *value = PyList_GetItem(propertyValue,i);
783 uint64A[i] = PyLong_AsUnsignedLong(value);
784 }
785 miUint64A.data = uint64A;
786 value.uint64a = miUint64A;
787 *miValue = value;
788 break;
789 }
790 case MI_SINT64A:
791 {
792 Py_ssize_t size = PyList_Size(propertyValue);
793 MI_Sint64A miSint64A;
794 miSint64A.size = size;
795 int i;
796 MI_Sint64 sint64A[size];
797 for (i = 0; i < size; i++)
798 {
799 krisbash 1.1 PyObject *value = PyList_GetItem(propertyValue,i);
800 sint64A[i] = PyLong_AsLong(value);
801 }
802 miSint64A.data = sint64A;
803 value.sint64a = miSint64A;
804 *miValue = value;
805 break;
806 }
807 case MI_REAL32A:
808 {
809 Py_ssize_t size = PyList_Size(propertyValue);
810 MI_Real32A miReal32A;
811 miReal32A.size = size;
812 int i;
813 MI_Real32 real32A[size];
814 for (i = 0; i < size; i++)
815 {
816 PyObject *value = PyList_GetItem(propertyValue,i);
817 real32A[i] = PyFloat_AsDouble(value);
818 }
819 miReal32A.data = real32A;
820 krisbash 1.1 value.real32a = miReal32A;
821 *miValue = value;
822 break;
823 }
824 case MI_REAL64A:
825 {
826 Py_ssize_t size = PyList_Size(propertyValue);
827 MI_Real64A miReal64A;
828 miReal64A.size = size;
829 int i;
830 MI_Real64 real64A[size];
831 for (i = 0; i < size; i++)
832 {
833 PyObject *value = PyList_GetItem(propertyValue,i);
834 real64A[i] = PyFloat_AsDouble(value);
835 }
836 miReal64A.data = real64A;
837 value.real64a = miReal64A;
838 *miValue = value;
839 break;
840 }
841 krisbash 1.1 case MI_CHAR16A:
842 {
843 Py_ssize_t size = PyList_Size(propertyValue);
844 MI_Char16A miChar16A;
845 miChar16A.size = size;
846 int i;
847 MI_Char16 char16A[size];
848 for (i = 0; i < size; i++)
849 {
850 PyObject *value = PyList_GetItem(propertyValue,i);
851 char16A[i] = PyInt_AsLong(value);
852 }
853 miChar16A.data = char16A;
854 value.char16a = miChar16A;
855 *miValue = value;
856 break;
857 }
858 case MI_STRINGA:
859 {
860 Py_ssize_t size = PyList_Size(propertyValue);
861 MI_StringA miStringA;
862 krisbash 1.1 miStringA.size = size;
863 int i;
864 MI_Char *stringA[size];
865 for (i = 0; i < size; i++)
866 {
867 PyObject *value = PyList_GetItem(propertyValue,i);
868 stringA[i] = PyString_AsString(value);
869 }
870 miStringA.data = stringA;
871 value.stringa = miStringA;
872 *miValue = value;
873 break;
874 }
875 case MI_DATETIMEA:
876 {
877 //to implement
878 Py_ssize_t size = PyList_Size(propertyValue);
879 MI_DatetimeA miDatetimeA;
880 miDatetimeA.size = size;
881 break;
882 }
883 krisbash 1.1 case MI_INSTANCE:
884 {
885 PMI_Instance *pmiInstance = (PMI_Instance *)propertyValue;
886 MI_Instance *miInstance = pmiInstance->miInstance;
887 value.instance = miInstance;
888 *miValue = value;
889 break;
890 }
891 case MI_REFERENCE:
892 {
893 PMI_Instance *pmiInstance = (PMI_Instance *)propertyValue;
894 MI_Instance *miReference = pmiInstance->miInstance;
895 value.reference = miReference;
896 *miValue = value;
897 break;
898 }
899 case MI_INSTANCEA:
900 {
901 Py_ssize_t size = PyList_Size(propertyValue);
902 MI_InstanceA miInstanceA;
903 miInstanceA.size = size;
904 krisbash 1.1 int i;
905 MI_Instance *instanceA[size];
906 for(i = 0; i< size; i++)
907 {
908 PyObject *value = PyList_GetItem(propertyValue,i);
909 PMI_Instance *pmiInstance = (PMI_Instance *)value;
910 instanceA[i] = pmiInstance->miInstance;
911 }
912 miInstanceA.data = instanceA;
913 value.instancea = miInstanceA;
914 *miValue = value;
915 break;
916 }
917 case MI_REFERENCEA:
918 {
919 Py_ssize_t size = PyList_Size(propertyValue);
920 MI_ReferenceA miReferenceA;
921 miReferenceA.size = size;
922 int i;
923 MI_Instance *referenceA[size];
924 for(i = 0; i< size; i++)
925 krisbash 1.1 {
926 PyObject *value = PyList_GetItem(propertyValue,i);
927 PMI_Instance *pmiInstance = (PMI_Instance *)value;
928 referenceA[i] = pmiInstance->miInstance;
929 }
930 miReferenceA.data = referenceA;
931 value.referencea = miReferenceA;
932 *miValue = value;
933 break;
934 }
935 }
936 }
937
938 static PyObject *EnumerateProperties(PMI_Instance *pmiInstance, char *propertyName)
939 {
940 if(pmiInstance->propertyValues == NULL)
941 {
942 Py_INCREF(Py_None);
943 return Py_None;
944 }
945 PyObject *propertyValues = pmiInstance->propertyValues;
946 krisbash 1.1 if(!strcmp(propertyName,"propertyValues"))
947 {
948 return propertyValues;
949 }
950 else if(!strcmp(propertyName,"propertyTypes"))
951 {
952 PyObject *propertyTypes = pmiInstance->propertyTypes;
953 return propertyTypes;
954 }
955 else if(!strcmp(propertyName,"propertyFlags"))
956 {
957 PyObject *propertyFlags = pmiInstance->propertyFlags;
958 return propertyFlags;
959 }
960 else
961 {
962 PyObject *value = PyDict_GetItemString(propertyValues,propertyName);
963 if(value == NULL)
964 {
965 PyErr_SetString(MIError,"MI_Instance doesn't have the property");
966 return NULL;
967 krisbash 1.1 }
968 return value;
969 }
970 }
971
972 static PyObject *GetProperty(PMI_Instance *self, char* propertyName)
973 {
974 return EnumerateProperties(self,propertyName);
975 }
976
977 static void SetProperty(PMI_Instance *self, char* propertyName, PyObject* value)
978 {
979 MI_Instance *miInstance = self->miInstance;
980 PyObject *propertyValues = self->propertyValues;
981 PyObject *newValue = PyDict_GetItemString(propertyValues,propertyName);
982 if(newValue == NULL)
983 {
984 PyErr_SetString(MIError,"MI_Instance doesn't have the property");
985 }
986 newValue = value;
987 if(PyDict_SetItemString(propertyValues,propertyName,newValue)<0)
988 krisbash 1.1 {
989 PyErr_SetString(MIError,"Set instance property failed");
990 }
991
992 PyObject *propertyTypes = self->propertyTypes;
993 PyObject *valueType = PyDict_GetItemString(propertyTypes,propertyName);
994 if(valueType == NULL)
995 {
996 PyErr_SetString(MIError,"MI_Instance doesn't have the property");
997 }
998 MI_Type miType = PyInt_AsLong(valueType);
999 MI_Value miValue;
1000 MI_Result miResult = MI_RESULT_OK;
1001 SetPropertyValues(miType,value,&miValue);
1002 miResult = MI_Instance_SetElement(miInstance,propertyName,&miValue,miType,0);
1003 if(miResult != MI_RESULT_OK)
1004 {
1005 PyErr_SetString(MIError,"MI_Instance set element failed");
1006 }
1007
1008 }
1009 krisbash 1.1
1010 static int PMI_Instance_init(PMI_Instance *self)
1011 {
1012 self-> miInstance = NULL;
1013 self->propertyValues = NULL;
1014 self->propertyTypes = NULL;
1015 self->propertyFlags = NULL;
1016 return 0;
1017 }
1018
1019 static PyMethodDef PMI_Instance_methods [] = {
1020 {NULL}
1021 };
1022
1023 static PyObject* PMI_Instance_getattr(PMI_Instance* self, char* propertyName)
1024 {
1025 PyObject *propertyValue = GetProperty(self, propertyName);
1026 Py_INCREF(propertyValue);
1027 return propertyValue;
1028 }
1029
1030 krisbash 1.1 static int PMI_Instance_setattr(PMI_Instance* self, char* propertyName, PyObject* value)
1031 {
1032 SetProperty(self,propertyName,value);
1033 return 0;
1034 }
1035
1036 static PyTypeObject PMI_InstanceType = {
1037 PyVarObject_HEAD_INIT(NULL, 0)
1038 "PMI_Instance.PMI_Instance", /* tp_name */
1039 sizeof(PMI_Instance), /* tp_basicsize */
1040 0, /* tp_itemsize */
1041 (destructor)PMI_Instance_dealloc, /* tp_dealloc */
1042 0, /* tp_print */
1043 (getattrfunc)PMI_Instance_getattr, /* tp_getattr */
1044 (setattrfunc)PMI_Instance_setattr, /* tp_setattr */
1045 0, /* tp_reserved */
1046 0, /* tp_repr */
1047 0, /* tp_as_number */
1048 0, /* tp_as_sequence */
1049 0, /* tp_as_mapping */
1050 0, /* tp_hash */
1051 krisbash 1.1 0, /* tp_call */
1052 0, /* tp_str */
1053 0, /* tp_getattro */
1054 0, /* tp_setattro */
1055 0, /* tp_as_buffer */
1056 Py_TPFLAGS_DEFAULT, /* tp_flags */
1057 "MI_Instance objects", /* tp_doc */
1058 0, /* tp_traverse */
1059 0, /* tp_clear */
1060 0, /* tp_richcompare */
1061 0, /* tp_weaklistoffset */
1062 0, /* tp_iter */
1063 0, /* tp_iternext */
1064 PMI_Instance_methods, /* tp_methods */
1065 0, /* tp_members */
1066 0, /* tp_getset */
1067 0, /* tp_base */
1068 0, /* tp_dict */
1069 0, /* tp_descr_get */
1070 0, /* tp_descr_set */
1071 0, /* tp_dictoffset */
1072 krisbash 1.1 (initproc)PMI_Instance_init, /* tp_init */
1073 0, /* tp_alloc */
1074 (newfunc)PMI_Instance_new, /* tp_new */
1075 };
1076
1077
1078 #define PyMODINIT_FUNC void
1079 #ifndef PyMODINIT_FUNC
1080 #endif
1081 PyMODINIT_FUNC
1082 initPMI_Instance(void)
1083 {
1084 PyObject *m;
1085 /*Make sure the new type object is initialized properly*/
1086 if (PyType_Ready(&PMI_InstanceType) <0)
1087 return;
1088 m = Py_InitModule3("mi",PMI_Instance_methods, "MI_Instance object");
1089 //Py_INCREF(&PMI_InstanceType);
1090
1091 /*Add the exception type to the module */
1092 MIError = PyErr_NewException("mi.error",NULL,NULL);
1093 krisbash 1.1 Py_INCREF(MIError);
1094 PyModule_AddObject(m,"MIError",MIError);
1095
1096 /*New type objects are all exported into mi module*/
1097 PyModule_AddObject(m, "PMI_Instance", (PyObject *)&PMI_InstanceType);
1098 PyDateTime_IMPORT;
1099 }
|
Return to
PMI_Instance.c
CVS log
Up to [OMI] / omi / scriptext / py