/** * Moves all the group's entries (recursively) to Backup group; subgroups are deleted. * Returns true if successful. */ bool PwGroupV3::moveToBackup() { PwGroup* parentGroup = this->getParentGroup(); if (!parentGroup) { LOG("PwGroupV3::moveToBackup fail - no parent group"); return false; } PwGroup* backupGroup = getDatabase()->getBackupGroup(true); // For v3, backupGroup is guaranteed to be not NULL parentGroup->removeSubGroup(this); // detach this branch from the parent group; memory will be released later. // flag the group and all its children deleted setDeleted(true); QList<PwGroup*> childGroups; QList<PwEntry*> childEntries; getAllChildren(childGroups, childEntries); // V3 does not backup subgroups, so move only entries for (int i = 0; i < childEntries.size(); i++) { if (!childEntries.at(i)->moveToBackup()) { LOG("PwGroupV3::moveToBackup fail on child entry"); return false; } } childGroups.clear(); childEntries.clear(); LOG("PwGroupV3::moveToBackup OK"); return true; }
void MythGenericTree::sortByString() { m_ordered_subnodes->Sort(SortableMythGenericTreeList::SORT_STRING); QList<MythGenericTree*> *children = getAllChildren(); if (children && children->count() > 0) { SortableMythGenericTreeList::Iterator it; MythGenericTree *child = NULL; for (it = children->begin(); it != children->end(); ++it) { child = *it; if (!child) continue; child->sortByString(); } } }
MythGenericTree* MythGenericTree::getChildById(int an_int) const { QList<MythGenericTree*> *children = getAllChildren(); if (children && children->count() > 0) { SortableMythGenericTreeList::Iterator it; MythGenericTree *child = NULL; for (it = children->begin(); it != children->end(); ++it) { child = *it; if (!child) continue; if (child->getInt() == an_int) return child; } } return NULL; }
MythGenericTree* MythGenericTree::getChildByName(const QString &a_name) const { QList<MythGenericTree*> *children = getAllChildren(); if (children && children->count() > 0) { SortableMythGenericTreeList::Iterator it; MythGenericTree *child = nullptr; for (it = children->begin(); it != children->end(); ++it) { child = *it; if (!child) continue; if (child->GetText() == a_name) return child; } } return nullptr; }
void TTreeWidget::mouseReleaseEvent( QMouseEvent *event ) { QModelIndex indexClicked = indexAt(event->pos()); if( mIsVarTree && indexClicked.isValid() && mClickedItem == indexClicked ) { QRect vrect = visualRect(indexClicked); int itemIndentation = vrect.x() - visualRect(rootIndex()).x(); QRect rect = QRect(header()->sectionViewportPosition(0) + itemIndentation, vrect.y(), style()->pixelMetric(QStyle::PM_IndicatorWidth), vrect.height()); if(rect.contains(event->pos())) { QTreeWidgetItem * clicked = itemFromIndex( indexClicked ); if ( ! ( clicked->flags()&Qt::ItemIsUserCheckable ) ) return; if ( clicked->checkState( 0 ) == Qt::Unchecked ) { clicked->setCheckState( 0, Qt::Checked ); //get all children and see what ones we can save QList< QTreeWidgetItem * > list; getAllChildren( clicked, list ); QListIterator< QTreeWidgetItem * > it(list); LuaInterface * lI = mpHost->getLuaInterface(); VarUnit * vu = lI->getVarUnit(); while( it.hasNext() ) { QTreeWidgetItem * item = it.next(); if ( ! vu->shouldSave( item ) ) item->setCheckState( 0, Qt::Unchecked ); } } else { clicked->setCheckState( 0, Qt::Unchecked ); } return; } } QTreeWidget::mouseReleaseEvent(event); }
ccHObject::Container vombat::getAllObjectsInTree() { // ccHObject::Container cont; ccHObject* dbroot = this->getMainAppInterface()->dbRootObject(); ccHObject::Container tovisit; tovisit.push_back(dbroot); ccHObject::Container out; while (!tovisit.empty()) { ccHObject* last = tovisit.back(); tovisit.pop_back(); out.push_back(last); ccHObject::Container sons = getAllChildren(last); for (ccHObject* obj : sons) { tovisit.push_back(obj); } } return out; }
void getContractNames(const XmimClientHandle& handle, T cont, const char* relname, const XmimUnits units) { std::vector<std::string> tickers; std::vector<bool> has_rows; std::vector<XmimRelType> relTypes; // read in all children getAllChildren(handle, std::back_inserter(tickers), relname); // find rel types getRelationTypes(handle, std::back_inserter(relTypes), tickers.begin(), tickers.end()); // see if there is actual data in the relation hasRows(handle, std::back_inserter(has_rows), tickers.begin(), tickers.end(), units); // drop out continuous contracts and such // only accept actual futures contracts std::vector<XmimRelType>::iterator relTypes_iter = relTypes.begin(); std::vector<bool>::iterator has_rows_iter = has_rows.begin(); for(std::vector<std::string>::iterator it = tickers.begin(); it != tickers.end(); it++) { if(*relTypes_iter == XMIM_REL_FUTURES_CONTRACT && *has_rows_iter) { *cont = *it; } ++cont; ++relTypes_iter; ++has_rows_iter; } }
void TTreeWidget::getAllChildren( QTreeWidgetItem *pItem, QList< QTreeWidgetItem * > & list) { list.append( pItem ); for(int i=0;i<pItem->childCount();++i) getAllChildren( pItem->child(i), list ); }
bool CollectionHandler::read(Variant& v, const NodePtr& node, const char* typeName) { // Check that we've been given a valid Variant if (v.isVoid() || v.type() == nullptr) { return false; } // Container, key, and value types TypeId containerType; TypeId keyVariantType; TypeId valueVariantType; std::string keyInternalType; std::string valueInternalType; // Container const char* containerName = this->getReservedNames().collectionContainerType; std::string containerTypeName = node->getChildNode(containerName, strlen(containerName))->getType(); containerType = TypeId(containerTypeName.c_str()); // Key variant type const char* keyVName = this->getReservedNames().collectionKeyVariantType; std::string keyVTypeName = node->getChildNode(keyVName, strlen(keyVName))->getType(); keyVariantType = TypeId(keyVTypeName.c_str()); // Value variant type const char* valueVName = this->getReservedNames().collectionValueVariantType; std::string valueVTypeName = node->getChildNode(valueVName, strlen(valueVName))->getType(); valueVariantType = TypeId(valueVTypeName.c_str()); // Key internal type const char* keyIName = this->getReservedNames().collectionKeyInternalType; keyInternalType = node->getChildNode(keyIName, strlen(keyIName))->getType(); // Value internal type const char* valueIName = this->getReservedNames().collectionValueInternalType; valueInternalType = node->getChildNode(valueIName, strlen(valueIName))->getType(); // Cast to a collection Collection c; if (!v.tryCast<Collection>(c)) { return false; } // Check that the types match if (strcmp(c.impl()->containerType().getName(), containerType.getName()) != 0) { return false; } // Get handlers std::shared_ptr<SerializationHandler> keyHandler = nullptr; std::shared_ptr<SerializationHandler> valueHandler = nullptr; if (MetaType::find(keyVariantType.getName()) != MetaType::get<Variant>()) { const char* keyHandlerName = this->getReservedNames().collectionKeyHandler; auto keyHandlerNode = node->getChildNode(keyHandlerName, strlen(keyHandlerName)); std::string keyHandlerString = keyHandlerNode->getValueString(); keyHandler = handlerManager_.findHandlerRead(node, keyHandlerString.c_str(), keyInternalType.c_str()); } if (MetaType::find(valueVariantType.getName()) != MetaType::get<Variant>()) { const char* valueHandlerName = this->getReservedNames().collectionValueHandler; auto valueHandlerNode = node->getChildNode(valueHandlerName, strlen(valueHandlerName)); std::string valueHandlerString = valueHandlerNode->getValueString(); valueHandler = handlerManager_.findHandlerRead(node, valueHandlerString.c_str(), valueInternalType.c_str()); } // Get the base node of the collection auto baseNode = node->getChildNode(collectionBaseNodeName_, strlen(collectionBaseNodeName_)); auto nodeChildren = baseNode->getAllChildren(); auto collectionIter = c.begin(); // Iterate through all the children until we reach the nodes for storing type data for (auto nodeIter = nodeChildren.begin(); nodeIter != nodeChildren.end(); ++nodeIter) { std::unique_ptr<SerializationNode>& currentNode = *nodeIter; Variant key = Variant(keyVariantType); // Assign key/value if (currentNode->getName() != keyName_) { return false; } // Read the key node if (keyHandler.get() == nullptr) { // Read as a Variant if (!currentNode->getValueVariant(key, keyVariantType.getName())) { return false; } } else { // Read with a handler, using the type supplied if (!keyHandler->read(key, currentNode, keyVariantType.getName())) { return false; } } // Insert/get the key, which creates the value for us. Collection::Iterator insertIter; if (c.canResize()) { insertIter = c.insert(key); } else { if (key != collectionIter.key()) { return false; } insertIter = collectionIter; ++collectionIter; } if (insertIter == c.end()) { return false; } Variant value = insertIter.value(); auto childNode = currentNode->getChildNode(valueName_, strlen(valueName_)); if (childNode == nullptr) { return false; } // Read the value node if (valueHandler.get() == nullptr) { // Read as a Variant if (!childNode->getValueVariant(value, valueVariantType.getName())) { return false; } } else { // Read with a handler, using the type supplied if (!valueHandler->read(value, childNode, valueVariantType.getName())) { return false; } } // If this collection doesn't support setting values, then it's invalid. if (!insertIter.setValue(value)) { return false; } } return true; }