static PyObject* convert( const multi_array_t & c_array ) { object numpy = object( handle<>(::PyImport_Import(object("numpy").ptr()))); if( !numpy ) { throw std::logic_error( "Could not import numpy" ); } object array_function = numpy.attr("empty"); if( !array_function ) { throw std::logic_error( "Could not find array function" ); } //create a numpy array to put it in boost::python::list extents; for( unsigned dim = 0; c_array.num_dimensions() != dim; ++dim ) { extents.append( c_array.shape()[ dim ] ); } object result(array_function( extents,numpy.attr( "dtype" ) ( mydetail::get_dtype<typename multi_array_t::element>::name()))); //copy the elements index i( c_array.num_dimensions(), 0 ); do { boost::python::list numpy_index; for( unsigned dim = 0; c_array.num_dimensions() != dim; ++dim ) { numpy_index.append(i[dim]); } result[ tuple( numpy_index ) ] = c_array( i ); } while( increment_index( i, c_array ) ); return incref( result.ptr() ); }
void Uuid::decode(Buffer& buf) { if (buf.available() < size()) throw IllegalArgumentException(QPID_MSG("Not enough data for UUID.")); buf.getRawData(c_array(), size()); }
void Uuid::clear() { uuid_clear(c_array()); }
void Uuid::generate() { uuid_generate(c_array()); }
static c_bool c__cloneReferences ( c_type type, c_voidp data, c_voidp dest) { c_type refType; c_class cls; c_array references, labels, ar, destar; c_sequence seq, destseq; c_property property; c_member member; c_long i,j,length,size; c_long nrOfRefs,nrOfLabs; c_value v; switch (c_baseObject(type)->kind) { case M_CLASS: cls = c_class(type); while (cls) { length = c_arraySize(c_interface(cls)->references); for (i=0;i<length;i++) { property = c_property(c_interface(cls)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } cls = cls->extends; } break; case M_INTERFACE: length = c_arraySize(c_interface(type)->references); for (i=0;i<length;i++) { property = c_property(c_interface(type)->references[i]); refType = property->type; _cloneReference(refType, C_DISPLACE(data, property->offset), C_DISPLACE(dest, property->offset)); } break; case M_EXCEPTION: case M_STRUCTURE: length = c_arraySize(c_structure(type)->references); for (i=0;i<length;i++) { member = c_member(c_structure(type)->references[i]); refType = c_specifier(member)->type; _cloneReference(refType, C_DISPLACE(data, member->offset), C_DISPLACE(dest, member->offset)); } break; case M_UNION: #define _CASE_(k,t) case k: v = t##Value(*((t *)data)); break switch (c_metaValueKind(c_metaObject(c_union(type)->switchType))) { _CASE_(V_BOOLEAN, c_bool); _CASE_(V_OCTET, c_octet); _CASE_(V_SHORT, c_short); _CASE_(V_LONG, c_long); _CASE_(V_LONGLONG, c_longlong); _CASE_(V_USHORT, c_ushort); _CASE_(V_ULONG, c_ulong); _CASE_(V_ULONGLONG, c_ulonglong); _CASE_(V_CHAR, c_char); _CASE_(V_WCHAR, c_wchar); default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal union switch type detected"); assert(FALSE); return FALSE; break; } #undef _CASE_ references = c_union(type)->references; if (references != NULL) { i=0; refType=NULL; nrOfRefs = c_arraySize(references); while ((i<nrOfRefs) && (refType == NULL)) { labels = c_unionCase(references[i])->labels; j=0; nrOfLabs = c_arraySize(labels); while ((j<nrOfLabs) && (refType == NULL)) { if (c_valueCompare(v,c_literal(labels[j])->value) == C_EQ) { c__cloneReferences(c_type(references[i]), C_DISPLACE(data, c_type(type)->alignment), C_DISPLACE(dest, c_type(type)->alignment)); refType = c_specifier(references[i])->type; } j++; } i++; } } break; case M_COLLECTION: refType = c_typeActualType(c_collectionType(type)->subType); switch (c_collectionType(type)->kind) { case C_ARRAY: ar = c_array(data); destar = c_array(dest); length = c_collectionType(type)->maxSize; if (length == 0) { length = c_arraySize(ar); } if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, ar[i], &destar[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(data, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; case C_SEQUENCE: seq = c_sequence(data); destseq = c_sequence(dest); length = c_sequenceSize(seq); if (c_typeIsRef(refType)) { for (i=0;i<length;i++) { c_cloneIn(refType, seq[i], &destseq[i]); } } else { if (c_typeHasRef(refType)) { size = refType->size; for (i=0;i<length;i++) { _cloneReference(refType, C_DISPLACE(seq, (i*size)), C_DISPLACE(dest, (i*size))); } } } break; default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal collectionType found"); break; } break; case M_BASE: break; case M_TYPEDEF: c__cloneReferences(c_type(c_typeDef(type)->alias), data, dest); break; case M_ATTRIBUTE: case M_RELATION: refType = c_typeActualType(c_property(type)->type); _cloneReference(refType, C_DISPLACE(data, c_property(type)->offset), C_DISPLACE(dest, c_property(type)->offset)); break; case M_MEMBER: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, C_DISPLACE(data, c_member(type)->offset), C_DISPLACE(dest, c_member(type)->offset)); break; case M_UNIONCASE: refType = c_typeActualType(c_specifier(type)->type); _cloneReference(refType, data, dest); break; case M_MODULE: /* Do nothing */ break; case M_PRIMITIVE: /* Do nothing */ break; case M_EXTENT: case M_EXTENTSYNC: default: OS_REPORT(OS_ERROR, "c__cloneReferences",0, "illegal meta object specified"); assert(FALSE); return FALSE; } return TRUE; }
void c_copyIn ( c_type type, c_voidp data, c_voidp *dest) { c_long size, subSize, i; c_type t, refType; if (data == NULL) { *dest = NULL; return; } t = c_typeActualType(type); if (c_baseObject(t)->kind == M_COLLECTION) { switch(c_collectionType(t)->kind) { case C_STRING: *dest = c_stringNew(c_getBase(t),data); return; case C_LIST: case C_BAG: case C_SET: case C_MAP: case C_DICTIONARY: OS_REPORT(OS_WARNING,"Database misc",0, "c_copyIn: ODL collections unsupported"); break; case C_ARRAY: refType = c_typeActualType(c_collectionType(type)->subType); subSize = refType->size; size = c_collectionType(t)->maxSize; if (size == 0) { size = c_arraySize(data); *dest = c_newArray(c_collectionType(t), size); } if (size > 0) { c_array ar = c_array(data); c_array destar = c_array(*dest); if (c_typeIsRef(refType)) { for (i = 0; i < size; i++) { copyReferences(refType, destar[i], ar[i]); } } else { memcpy(*dest, data, size * subSize); /* Find indirections */ for (i = 0; i < size; i++) { copyReferences(refType, C_DISPLACE(destar, (i*subSize)), C_DISPLACE(ar, (i*subSize))); } } } break; case C_SEQUENCE: refType = c_typeActualType(c_collectionType(type)->subType); subSize = refType->size; size = c_sequenceSize(data); if (size > 0) { *dest = c_newSequence(c_collectionType(t), size); if (c_typeIsRef(refType)) { c_sequence seq = c_sequence(data); c_sequence destseq = c_sequence(*dest); for (i = 0; i < size; i++) { copyReferences(refType, destseq[i], seq[i]); } } else { memcpy(*dest, data, size * subSize); /* Find indirections */ for (i = 0; i < size; i++) { copyReferences(refType, C_DISPLACE(*dest, (i*subSize)), C_DISPLACE(data, (i*subSize))); } } } break; default: OS_REPORT_1(OS_ERROR,"Database misc",0, "c_copyIn: unknown collection kind (%d)", c_collectionType(t)->kind); assert(FALSE); break; } } else if (c_typeIsRef(t)) { *dest = c_new(t); memcpy(*dest, data, t->size); copyReferences(t, *dest, data); } else { memcpy(*dest, data, t->size); copyReferences(t, *dest, data); } }