java::lang::String* rice::p2p::glacier::v2::messaging::GlacierResponseMessage::toString()
{
return ::java::lang::StringBuilder().append(u"[GlacierResponse for "_j)->append(static_cast< ::java::lang::Object* >((*keys)[int32_t(0)]))
->append(u" ("_j)
->append((numKeys() - int32_t(1)))
->append(u" more keys)]"_j)->toString();
}
void GroupByScan::executeGroupBy() {
auto resultTab = createResultTableLayout();
auto groupResults = getInputHashTable();
// Allocate some memory for the result tab and resize the table
resultTab->resize(groupResults->numKeys());
pos_t row = 0;
typename HashTableType::map_const_iterator_t it1, it2, end;
// set iterators: in the sequential case, getInputTable() returns an AggregateHashTable, in the parallel case a HashTableView<>
// Alternatively, a common type could be introduced
if (_count < 1) {
auto aggregateHashTable = std::dynamic_pointer_cast<const HashTableType>(groupResults);
it1 = aggregateHashTable->getMapBegin();
end = aggregateHashTable->getMapEnd();
} else {
auto hashTableView = std::dynamic_pointer_cast<const HashTableView<MapType, KeyType> >(groupResults);
it1 = hashTableView->getMapBegin();
end = hashTableView->getMapEnd();
}
for (it2 = it1; it1 != end; it1 = it2) {
// outer loop over unique keys
auto pos_list = std::make_shared<pos_list_t>();
for (; (it2 != end) && (it1->first == it2->first); ++it2) {
// inner loop, all keys equal to it1->first
pos_list->push_back(it2->second);
}
writeGroupResult(resultTab, pos_list, row);
row++;
}
this->addResult(resultTab);
}
TEST_F(HashBuildTest, merge_two_tables_test) {
// reference hash Table
std::shared_ptr<AbstractTable> t = Loader::shortcuts::load("test/10_30_group.tbl");
HashBuild hb;
hb.addInput(t);
hb.addField(1);
hb.setKey("groupby");
hb.execute();
auto hash = std::dynamic_pointer_cast<const SingleAggregateHashTable >(hb.getResultHashTable());
//test to merge two tables
auto t1 = storage::TableRangeView::create(t, 0, 5);
auto t2 = storage::TableRangeView::create(t, 5, 10);
HashBuild hb1;
hb1.addInput(t1);
hb1.addField(1);
hb1.setKey("groupby");
hb1.execute();
auto hash1 = std::dynamic_pointer_cast<const SingleAggregateHashTable >(hb1.getResultHashTable());
HashBuild hb2;
hb2.addInput(t2);
hb2.addField(1);
hb2.setKey("groupby");
hb2.execute();
auto hash2 = std::dynamic_pointer_cast<const SingleAggregateHashTable >(hb2.getResultHashTable());
MergeHashTables mht;
mht.addInput(hash1);
mht.addInput(hash2);
mht.setKey("groupby");
mht.execute();
auto hash3 = std::dynamic_pointer_cast<const SingleAggregateHashTable >(mht.getResultHashTable());
ASSERT_EQ(hash->size(), hash3->size());
ASSERT_EQ(hash->numKeys(), hash3->numKeys());
}
/*
* Delete anything stored in a keychain during decode, called on
* decode error.
* Currently the only thing we have to deal with is private keys,
* since certs and CRLs don't get stored until the end of a successful
* decode.
*/
void P12Coder::deleteDecodedItems()
{
if(!(mImportFlags & kSecImportKeys)) {
/* no keys stored, done */
return;
}
if(mDlDbHand.DLHandle == 0) {
/* no keychain, done */
return;
}
unsigned nKeys = numKeys();
for(unsigned dex=0; dex<nKeys; dex++) {
P12KeyBag *keyBag = mKeys[dex];
p12DeleteKey(mDlDbHand, keyBag->label());
}
}
/*
* Assign appropriate public key hash attribute to each
* private key.
*/
void P12Coder::setPrivateKeyHashes()
{
CSSM_KEY_PTR newKey;
for(unsigned dex=0; dex<numKeys(); dex++) {
P12KeyBag *keyBag = mKeys[dex];
CSSM_DATA newLabel = {0, NULL};
CFStringRef friendlyName = keyBag->friendlyName();
newKey = NULL;
CSSM_RETURN crtn = p12SetPubKeyHash(mCspHand,
mDlDbHand,
keyBag->label(),
p12StringToUtf8(friendlyName, mCoder),
mCoder,
newLabel,
newKey);
if(friendlyName) {
CFRelease(friendlyName);
}
switch(crtn) {
case CSSM_OK:
/* update key's label in case we have to delete on error */
keyBag->setLabel(newLabel);
p12DecodeLog("set pub key hash for private key");
break;
case CSSMERR_DL_INVALID_UNIQUE_INDEX_DATA:
/*
* Special case: update keyBag's CSSM_KEY and proceed without error
*/
p12DecodeLog("ignoring dup private key");
assert(newKey != NULL);
keyBag->setKey(newKey);
keyBag->dupKey(true);
/* update key's label in case we have to delete on error */
keyBag->setLabel(newLabel);
break;
default:
p12ErrorLog("p12SetPubKeyHash failure\n");
CssmError::throwMe(crtn);
}
}
}
/*
* Post keychain notification for imported keys.
*/
void P12Coder::notifyKeyImport()
{
if(mKeychain == NULL) {
/* Can't notify if user only gave us DLDB */
return;
}
for(unsigned dex=0; dex<numKeys(); dex++) {
P12KeyBag *keyBag = mKeys[dex];
if(keyBag->dupKey()) {
/* no notification for keys we merely looked up */
continue;
}
CssmData &labelData = CssmData::overlay(keyBag->label());
OSStatus ortn = impExpKeyNotify(mKeychain, labelData, *keyBag->key());
if(ortn) {
p12ErrorLog("notifyKeyImport: impExpKeyNotify returned %ld\n", (unsigned long)ortn);
MacOSError::throwMe(ortn);
}
}
}
