//------------------------------------------------------------------- double *cpp_xloper::ConvertMultiToDouble(void) { if(m_Op.xltype != xltypeMulti) return NULL; // Allocate the space for the array of doubles int size = m_Op.val.array.rows * m_Op.val.array.columns; double *ret_array = (double *)malloc(size * sizeof(double)); if(!ret_array) return NULL; // Get the cell values one-by-one as doubles and place in the array. // Store the array row-by-row in memory. xloper *p_op = m_Op.val.array.lparray; if(!p_op) { free(ret_array); return NULL; } double *p = ret_array; for(; size--; p++) if(!coerce_to_double(p_op++, *p)) *p = 0.0; return ret_array; // caller must free the memory! }
//------------------------------------------------------------------- cpp_xloper::operator double(void) { double d; if(coerce_to_double(&m_Op, d)) return d; return 0.0; }
//------------------------------------------------------------------- bool cpp_xloper::operator==(double d) { double dd; if(!coerce_to_double(&m_Op, dd) || dd != d) return false; return true; }
//------------------------------------------------------------------- xl_array *cpp_xloper::AsDblArray(void) { xl_array *p_ret_array; double *p; int size; xloper *p_op; switch(m_Op.xltype) { case xltypeMulti: size = m_Op.val.array.rows * m_Op.val.array.columns; p_ret_array = (xl_array *)malloc(sizeof(xl_array) + sizeof(double) * (size - 1)); p_ret_array->columns = m_Op.val.array.columns; p_ret_array->rows = m_Op.val.array.rows; if(!p_ret_array) return NULL; // Get the cell values one-by-one as doubles and place in the array. // Store the array row-by-row in memory. if(!(p_op = m_Op.val.array.lparray)) { free(p_ret_array); return NULL; } for(p = p_ret_array->array; size--; p++) if(!coerce_to_double(p_op++, *p)) *p = 0.0; return p_ret_array; case xltypeNum: case xltypeStr: case xltypeBool: p_ret_array = (xl_array *)malloc(sizeof(xl_array)); p_ret_array->columns = p_ret_array->rows = 1; if(!coerce_to_double(&m_Op, p_ret_array->array[0])) p_ret_array->array[0] = 0.0; return p_ret_array; } return NULL; }
//------------------------------------------------------------------- // Allocate and populate an array of doubles based on input xloper //------------------------------------------------------------------- double *coerce_to_double_array(const xloper *p_op, double invalid_value, RW &cols, COL &rows) { if(!p_op || (p_op->xltype & (xltypeMissing | xltypeNil))) return NULL; // xloper is not an xloper array type, so try to convert it. xloper ret_val; if(!coerce_xloper(p_op, ret_val, xltypeMulti)) return NULL; // Allocate the space for the array of doubles cols = ret_val.val.array.columns; rows = ret_val.val.array.rows; int size = rows * cols; double *d_array = (double *)malloc(size * sizeof(double)); if(!d_array) { // Must free array memory allocated by xlCoerce Excel4(xlFree, 0, 1, &ret_val); return NULL; } // Get the cell values one-by-one as doubles and place in the array. // Store the array row-by-row in memory. xloper *p_elt = ret_val.val.array.lparray; if(!p_elt) // array could not be created { // Must free array memory allocated by xlCoerce Excel4(xlFree, 0, 1, &ret_val); free(d_array); return NULL; } double *p = d_array; for(; size--; p++) if(!coerce_to_double(p_elt++, *p)) *p = invalid_value; Excel4(xlFree, 0, 1, &ret_val); return d_array; // caller must free this }
//------------------------------------------------------------------- bool cpp_xloper::GetArrayElement(DWORD offset, double &d) { return coerce_to_double(GetArrayElement(offset), d); }
//------------------------------------------------------------------- bool cpp_xloper::GetArrayElement(WORD row, WORD column, double &d) { return coerce_to_double(GetArrayElement(row, column), d); }