static int
keyBinding2xml(CMPIObjectPath * op, UtilStringBuffer * sb)
{
int i,
m;
_SFCB_ENTER(TRACE_CIMXMLPROC, "keyBinding2xml");
for (i = 0, m = CMGetKeyCount(op, NULL); i < m; i++) {
const char *name;
char *type;
CMPIData data;
data = opGetKeyCharsAt(op, i, &name, NULL);
SFCB_APPENDCHARS_BLOCK(sb, "<KEYBINDING NAME=\"");
sb->ft->appendChars(sb, name);
SFCB_APPENDCHARS_BLOCK(sb, "\">\n");
type = keyType(data.type);
if (*type == '*' && data.value.ref) {
refValue2xml(data.value.ref, sb);
} else {
SFCB_APPENDCHARS_BLOCK(sb, "<KEYVALUE VALUETYPE=\"");
sb->ft->appendChars(sb, type);
SFCB_APPENDCHARS_BLOCK(sb, "\">");
value2xml(data, sb, 0);
SFCB_APPENDCHARS_BLOCK(sb, "</KEYVALUE>\n");
}
SFCB_APPENDCHARS_BLOCK(sb, "</KEYBINDING>\n");
}
_SFCB_RETURN(0);
}
Foam::dictionaryEntry::dictionaryEntry
(
const dictionary& parentDict,
Istream& is
)
:
entry(keyType(is)),
dictionary(parentDict, is)
{
is.fatalCheck
(
"dictionaryEntry::dictionaryEntry"
"(const dictionary& parentDict, Istream&)"
);
}
int GetCharFromEvent(TEvent &E, char *Ch) {
*Ch = 0;
if (E.Key.Code & kfModifier)
return 0;
if (kbCode(E.Key.Code) == kbEsc) {
*Ch = 27;
return 1;
}
if (kbCode(E.Key.Code) == kbEnter) {
*Ch = 13;
return 1;
}
if (kbCode(E.Key.Code) == (kbEnter | kfCtrl)) {
*Ch = 10;
return 1;
}
if (kbCode(E.Key.Code) == kbBackSp) {
*Ch = 8;
return 1;
}
if (kbCode(E.Key.Code) == (kbBackSp | kfCtrl)) {
*Ch = 127;
return 1;
}
if (kbCode(E.Key.Code) == kbTab) {
*Ch = 9;
return 1;
}
if (kbCode(E.Key.Code) == kbDel) {
*Ch = 127;
return 1;
}
if (keyType(E.Key.Code) == kfCtrl) {
*Ch = (char)(E.Key.Code & 0x1F);
return 1;
}
if (isAscii(E.Key.Code)) {
*Ch = (char)E.Key.Code;
return 1;
}
return 0;
}
QCString QDBusData::buildDBusSignature() const
{
QCString signature;
switch (d->type)
{
case QDBusData::List:
{
QDBusDataList* list = (QDBusDataList*) d->value.pointer;
signature = DBUS_TYPE_ARRAY_AS_STRING;
if (list->hasContainerItemType())
signature += list->containerItemType().buildDBusSignature();
else
signature += qDBusTypeForQDBusType(list->type());
break;
}
case QDBusData::Struct:
{
signature += DBUS_STRUCT_BEGIN_CHAR;
QValueList<QDBusData>* memberList =
(QValueList<QDBusData>*) d->value.pointer;
QValueList<QDBusData>::ConstIterator it = (*memberList).begin();
QValueList<QDBusData>::ConstIterator endIt = (*memberList).end();
for (; it != endIt; ++it)
{
signature += (*it).buildDBusSignature();
}
signature += DBUS_STRUCT_END_CHAR;
break;
}
case QDBusData::Map:
signature += DBUS_TYPE_ARRAY_AS_STRING;
signature += DBUS_DICT_ENTRY_BEGIN_CHAR;
signature += qDBusTypeForQDBusType(keyType());
switch (keyType())
{
case QDBusData::Byte:
signature += qDBusSignatureForMapValue<Q_UINT8>(
*((QDBusDataMap<Q_UINT8>*) d->value.pointer));
break;
case QDBusData::Int16:
signature += qDBusSignatureForMapValue<Q_INT16>(
*((QDBusDataMap<Q_INT16>*) d->value.pointer));
break;
case QDBusData::UInt16:
signature += qDBusSignatureForMapValue<Q_UINT16>(
*((QDBusDataMap<Q_UINT16>*) d->value.pointer));
break;
case QDBusData::Int32:
signature += qDBusSignatureForMapValue<Q_INT32>(
*((QDBusDataMap<Q_INT32>*) d->value.pointer));
break;
case QDBusData::UInt32:
signature += qDBusSignatureForMapValue<Q_UINT32>(
*((QDBusDataMap<Q_UINT32>*) d->value.pointer));
break;
case QDBusData::Int64:
signature += qDBusSignatureForMapValue<Q_INT64>(
*((QDBusDataMap<Q_INT64>*) d->value.pointer));
break;
case QDBusData::UInt64:
signature += qDBusSignatureForMapValue<Q_UINT64>(
*((QDBusDataMap<Q_UINT64>*) d->value.pointer));
break;
case QDBusData::String:
signature += qDBusSignatureForMapValue<QString>(
*((QDBusDataMap<QString>*) d->value.pointer));
break;
case QDBusData::ObjectPath:
signature += qDBusSignatureForMapValue<QDBusObjectPath>(
*((QDBusDataMap<QDBusObjectPath>*) d->value.pointer));
break;
default:
break;
}
signature += DBUS_DICT_ENTRY_END_CHAR;
break;
default:
signature = qDBusTypeForQDBusType(d->type);
break;
}
return signature;
}
void TimelineCollection::addSpec(
const string &nameExpr,
const string &headerSpecString
) {
headerSpecs_.set(keyType(nameExpr),headerSpecString);
}
void
Dbtux::execTUX_ADD_ATTRREQ(Signal* signal)
{
jamEntry();
const TuxAddAttrReq reqCopy = *(const TuxAddAttrReq*)signal->getDataPtr();
const TuxAddAttrReq* const req = &reqCopy;
// get the records
FragOpPtr fragOpPtr;
IndexPtr indexPtr;
c_fragOpPool.getPtr(fragOpPtr, req->tuxConnectPtr);
c_indexPool.getPtr(indexPtr, fragOpPtr.p->m_indexId);
TuxAddAttrRef::ErrorCode errorCode = TuxAddAttrRef::NoError;
do {
// expected attribute id
const unsigned attrId = fragOpPtr.p->m_numAttrsRecvd++;
ndbrequire(
indexPtr.p->m_state == Index::Defining &&
attrId < indexPtr.p->m_numAttrs &&
attrId == req->attrId);
const Uint32 ad = req->attrDescriptor;
const Uint32 typeId = AttributeDescriptor::getType(ad);
const Uint32 sizeInBytes = AttributeDescriptor::getSizeInBytes(ad);
const Uint32 nullable = AttributeDescriptor::getNullable(ad);
const Uint32 csNumber = req->extTypeInfo >> 16;
const Uint32 primaryAttrId = req->primaryAttrId;
DescHead& descHead = getDescHead(*indexPtr.p);
// add type to spec
KeySpec& keySpec = indexPtr.p->m_keySpec;
KeyType keyType(typeId, sizeInBytes, nullable, csNumber);
if (keySpec.add(keyType) == -1) {
jam();
errorCode = TuxAddAttrRef::InvalidAttributeType;
break;
}
// add primary attr to read keys array
AttributeHeader* keyAttrs = getKeyAttrs(descHead);
AttributeHeader& keyAttr = keyAttrs[attrId];
new (&keyAttr) AttributeHeader(primaryAttrId, sizeInBytes);
#ifdef VM_TRACE
if (debugFlags & DebugMeta) {
debugOut << "attr " << attrId << " " << keyType << endl;
}
#endif
if (csNumber != 0) {
unsigned err;
CHARSET_INFO *cs = all_charsets[csNumber];
ndbrequire(cs != 0);
if ((err = NdbSqlUtil::check_column_for_ordered_index(typeId, cs))) {
jam();
errorCode = (TuxAddAttrRef::ErrorCode) err;
break;
}
}
const bool lastAttr = (indexPtr.p->m_numAttrs == fragOpPtr.p->m_numAttrsRecvd);
if ((ERROR_INSERTED(12003) && attrId == 0) ||
(ERROR_INSERTED(12004) && lastAttr))
{
errorCode = (TuxAddAttrRef::ErrorCode)1;
CLEAR_ERROR_INSERT_VALUE;
break;
}
if (lastAttr) {
// compute min prefix
const KeySpec& keySpec = indexPtr.p->m_keySpec;
unsigned attrs = 0;
unsigned bytes = keySpec.get_nullmask_len(false);
unsigned maxAttrs = indexPtr.p->m_numAttrs;
#ifdef VM_TRACE
#ifdef NDB_USE_GET_ENV
{
const char* p = NdbEnv_GetEnv("MAX_TTREE_PREF_ATTRS", (char*)0, 0);
if (p != 0 && p[0] != 0 && maxAttrs > (unsigned)atoi(p))
maxAttrs = atoi(p);
}
#endif
#endif
while (attrs < maxAttrs) {
const KeyType& keyType = keySpec.get_type(attrs);
const unsigned newbytes = bytes + keyType.get_byte_size();
if (newbytes > (MAX_TTREE_PREF_SIZE << 2))
break;
attrs++;
bytes = newbytes;
}
if (attrs == 0)
bytes = 0;
indexPtr.p->m_prefAttrs = attrs;
indexPtr.p->m_prefBytes = bytes;
// fragment is defined
#ifdef VM_TRACE
if (debugFlags & DebugMeta) {
debugOut << "Release frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
}
#endif
c_fragOpPool.release(fragOpPtr);
}
// success
TuxAddAttrConf* conf = (TuxAddAttrConf*)signal->getDataPtrSend();
conf->userPtr = fragOpPtr.p->m_userPtr;
conf->lastAttr = lastAttr;
sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRCONF,
signal, TuxAddAttrConf::SignalLength, JBB);
return;
} while (0);
// error
TuxAddAttrRef* ref = (TuxAddAttrRef*)signal->getDataPtrSend();
ref->userPtr = fragOpPtr.p->m_userPtr;
ref->errorCode = errorCode;
sendSignal(fragOpPtr.p->m_userRef, GSN_TUX_ADD_ATTRREF,
signal, TuxAddAttrRef::SignalLength, JBB);
#ifdef VM_TRACE
if (debugFlags & DebugMeta) {
debugOut << "Release on attr error frag op " << fragOpPtr.i << " " << *fragOpPtr.p << endl;
}
#endif
// let DICT drop the unfinished index
}
