自学教程：C++ CHECK_OP函数代码示例

/** * Finds the destination file by @srcUrl and @role. * Checks hash for both destination and source files. * If hashes are ok then returns the destination file. */static QString getFileToFileInfo(const QString &srcUrl, const QString &role, WorkflowProcess &process) {    AppFileStorage *fileStorage = AppContext::getAppFileStorage();    if (NULL != fileStorage) {        U2OpStatus2Log os;        QString dstUrl = fileStorage->getFileInfo(srcUrl, role, process, os);        CHECK_OP(os, "");        if (!dstUrl.isEmpty() && QFile::exists(dstUrl)) {            QString srcHash = fileStorage->getFileInfo(srcUrl, StorageRoles::HASH, process, os);            CHECK_OP(os, "");            QString dstHash = fileStorage->getFileInfo(dstUrl, StorageRoles::HASH, process, os);            CHECK_OP(os, "");            if ((getCommonHashForFile(dstUrl) == dstHash) &&                (getCommonHashForFile(srcUrl) == srcHash)) {                FileInfo fToFInfo(srcUrl, role, dstUrl);                fileStorage->addFileOwner(fToFInfo, process, os);                CHECK_OP(os, "");                return dstUrl;            }        }    }    return "";}

QList<U2ObjectRelation> MysqlObjectRelationsDbi::getObjectRelations( const U2DataId &object,    U2OpStatus &os ){    QList<U2ObjectRelation> result;    static const QString queryString = "SELECT o.type, o.name, o_r.object, o_r.reference, o_r.role FROM ObjectRelation AS o_r "        "INNER JOIN Object AS o ON o.id = o_r.reference WHERE o_r.object = :object";    U2SqlQuery q( queryString, db, os );    CHECK_OP(os, result);    q.bindDataId( ":object", object );    while ( q.step( ) ) {        U2ObjectRelation relation;        const U2DataType objectType = U2DbiUtils::toType( object );        const U2DataType referenceType = q.getInt32( 0 );        relation.referencedType = U2ObjectTypeUtils::toGObjectType( referenceType );        relation.referencedName = q.getString( 1 );        relation.id = q.getDataId( 2, objectType );        relation.referencedObject = q.getDataId( 3, referenceType );        relation.relationRole = static_cast<GObjectRelationRole>( q.getInt32( 4 ) );        result << relation;        CHECK_OP(os, result);    }    return result;}

 int LMDBEngine::Del(const Slice& key, const Options& options) {     LMDBContext& holder = m_ctx_local.GetValue();     MDB_txn *txn = holder.readonly_txn;     if (NULL == txn || holder.batch_write == 0)     {         MDB_val k;         k.mv_data = const_cast<char*>(key.data());         k.mv_size = key.size();         CHECK_OP(mdb_txn_begin(m_env, NULL, 0, &txn));         CHECK_OP(mdb_del(txn, m_dbi, &k, NULL));         CHECK_OP(mdb_txn_commit(txn));         return 0;     }     DelOperation* op = new DelOperation;     op->key.assign((const char*) key.data(), key.size());     m_write_queue.Push(op);     if (holder.batch_write == 0)     {         CheckPointOperation* ck = new CheckPointOperation(holder.cond);         m_write_queue.Push(ck);         NotifyBackgroundThread();         ck->Wait();         DELETE(ck);         return 0;     }     return 0; }

Task::ReportResult GTest_DNAcompareSequencesInTwoObjects::report() {    Document* doc = getContext<Document>(this, docContextName);    if (doc == NULL) {        stateInfo.setError(QString("document not found %1").arg(docContextName));        return ReportResult_Finished;    }    Document* doc2 = getContext<Document>(this, secondDocContextName);    if (doc2 == NULL) {        stateInfo.setError(QString("document not found %1").arg(secondDocContextName));        return ReportResult_Finished;    }    const QList<GObject*>& objs = doc->getObjects();    const QList<GObject*>& objs2 = doc2->getObjects();    GObject*obj=NULL;    GObject*obj2=NULL;    U2SequenceObject * mySequence;    U2SequenceObject * mySequence2;    for(int i=0;(i!=objs.size())&&(i!=objs2.size());i++){        obj = objs.at(i);        obj2 = objs2.at(i);        if((obj->getGObjectType()== GObjectTypes::SEQUENCE)&&(obj2->getGObjectType()== GObjectTypes::SEQUENCE)){            mySequence = qobject_cast<U2SequenceObject*>(obj);            if(mySequence==NULL){                stateInfo.setError(QString("can't cast to sequence from: %1 in position %2").arg(obj->getGObjectName()).arg(i));                return ReportResult_Finished;            }            mySequence2 = qobject_cast<U2SequenceObject*>(obj2);            if(mySequence2==NULL){                stateInfo.setError(QString("can't cast to sequence from: %1 in position %2").arg(obj2->getGObjectName()).arg(i));                return ReportResult_Finished;            }            if(mySequence->getWholeSequenceData(stateInfo) != mySequence2->getWholeSequenceData(stateInfo)){                CHECK_OP(stateInfo, ReportResult_Finished);                stateInfo.setError(QString("Sequences of object in position %1 not matched").arg(i));                return ReportResult_Finished;            }            CHECK_OP(stateInfo, ReportResult_Finished);        }    }    if (objs.size() != objs2.size()) {        QString error("Number of objects in doc mismatches: [%1=%2] vs [%3=%4]");        error = error.arg(docContextName).arg(objs.size())            .arg(secondDocContextName).arg(objs2.size());        if (obj) {            error += QString("/nLast good object: %1").arg(obj->getGObjectName());        }        stateInfo.setError(error);    }    return ReportResult_Finished;}

void CProtoGearPrice::GetGearArrField(VT_PROTO_FIELD &vtField, const GearPriceAckItem &ackItem){	static BOOL arOptional[] = {		FALSE, FALSE, FALSE,		FALSE, FALSE, FALSE,	};	static EProtoFildType arFieldType[] = {		ProtoFild_Int32, ProtoFild_Int32, ProtoFild_Int64, 		ProtoFild_Int32, ProtoFild_Int32, ProtoFild_Int64, 	};	static LPCSTR arFieldKey[] = {		"BuyPrice",	  "BuyOrder",	"BuyVol", 		"SellPrice",  "SellOrder",	"SellVol", 	};	GearPriceAckItem &item = const_cast<GearPriceAckItem &>(ackItem);	void *arPtr[] = {		&item.nBuyPrice,	&item.nBuyOrder,	&item.nBuyVolume,		&item.nSellPrice,	&item.nSellOrder,	&item.nSellVolume,	};	CHECK_OP(_countof(arOptional) == _countof(arFieldType), NOOP);	CHECK_OP(_countof(arOptional) == _countof(arFieldKey), NOOP);	CHECK_OP(_countof(arOptional) == _countof(arPtr), NOOP);	vtField.clear();	PROTO_FIELD field;	for ( int n = 0; n < _countof(arOptional); n++ )	{		field.bOptional = arOptional[n];		field.eFieldType = arFieldType[n];		field.strFieldKey = arFieldKey[n];		switch (field.eFieldType)		{		case ProtoFild_Int32:			field.pInt32 = (int*)arPtr[n];			break;		case ProtoFild_Int64:			field.pInt64 = (INT64*)arPtr[n];			break;		case ProtoFild_StringA:			field.pStrA = (std::string*)arPtr[n];			break;		case ProtoFild_StringW:			field.pStrW = (std::wstring*)arPtr[n];			break;		default:			CHECK_OP(FALSE, NOOP);			break;		}		vtField.push_back(field);	}	}

//tomodify 7void CProtoQueryHKOrder::GetProtoBodyField_Req(VT_PROTO_FIELD &vtField, const ProtoReqBodyType &reqData){	static BOOL arOptional[] = {		TRUE, FALSE, 	};	static EProtoFildType arFieldType[] = {		ProtoFild_Int32, ProtoFild_Int32, 	};	static LPCSTR arFieldKey[] = {		"EnvType",	"Cookie",	};	ProtoReqBodyType &body = const_cast<ProtoReqBodyType &>(reqData);	void *arPtr[] = {		&body.nEnvType, &body.nCookie, 	};	CHECK_OP(_countof(arOptional) == _countof(arFieldType), NOOP);	CHECK_OP(_countof(arOptional) == _countof(arFieldKey), NOOP);	CHECK_OP(_countof(arOptional) == _countof(arPtr), NOOP);	vtField.clear();	PROTO_FIELD field;	for ( int n = 0; n < _countof(arOptional); n++ )	{		field.bOptional = arOptional[n];		field.eFieldType = arFieldType[n];		field.strFieldKey = arFieldKey[n];		switch (field.eFieldType)		{		case ProtoFild_Int32:			field.pInt32 = (int*)arPtr[n];			break;		case ProtoFild_Int64:			field.pInt64 = (INT64*)arPtr[n];			break;		case ProtoFild_StringA:			field.pStrA = (std::string*)arPtr[n];			break;		case ProtoFild_StringW:			field.pStrW = (std::wstring*)arPtr[n];			break;		default:			CHECK_OP(FALSE, NOOP);			break;		}		vtField.push_back(field);	}	}

 void LMDBIterator::Next() {     int rc;     rc = mdb_cursor_get(m_cursor, &m_key, &m_value, MDB_NEXT);     CHECK_OP(rc);     m_valid = rc == 0; }

QList<U2MsaRow> MysqlMsaDbi::getRows(const U2DataId& msaId, U2OpStatus& os) {    QList<U2MsaRow> res;    MysqlTransaction t(db, os);    Q_UNUSED(t);    static const QString rowString = "SELECT rowId, sequence, gstart, gend, length FROM MsaRow WHERE msa = :msa ORDER BY pos";    U2SqlQuery rowQuery(rowString, db, os);    rowQuery.bindDataId(":msa", msaId);    static const QString gapString = "SELECT gapStart, gapEnd FROM MsaRowGap WHERE msa = :msa AND rowId = :rowId ORDER BY gapStart";    while (rowQuery.step()) {        U2MsaRow row;        row.rowId = rowQuery.getInt64(0);        row.sequenceId = rowQuery.getDataId(1, U2Type::Sequence);        row.gstart = rowQuery.getInt64(2);        row.gend = rowQuery.getInt64(3);        row.length = rowQuery.getInt64(4);        U2SqlQuery gapQuery(gapString, db, os);        gapQuery.bindDataId(":msa", msaId);        gapQuery.bindInt64(":rowId", row.rowId);        while (gapQuery.step()) {            U2MsaGap gap;            gap.offset = gapQuery.getInt64(0);            gap.gap = gapQuery.getInt64(1) - gap.offset;            row.gaps.append(gap);        }        CHECK_OP(os, res);        res.append(row);    }    return res;}

 int LMDBEngine::Get(const Slice& key, std::string* value, const Options& options) {     MDB_val k, v;     k.mv_data = const_cast<char*>(key.data());     k.mv_size = key.size();     int rc;     LMDBContext& holder = m_ctx_local.GetValue();     MDB_txn *txn = holder.readonly_txn;     if (NULL == holder.readonly_txn)     {         rc = mdb_txn_begin(m_env, NULL, MDB_RDONLY, &txn);         if (rc != 0)         {             ERROR_LOG("Failed to create txn for get for reason:%s", mdb_strerror(rc));             return -1;         }     }     rc = mdb_get(txn, m_dbi, &k, &v);     if (NULL == holder.readonly_txn)     {         CHECK_OP(mdb_txn_commit(txn));     }     if (0 == rc && NULL != value && NULL != v.mv_data)     {         value->assign((const char*) v.mv_data, v.mv_size);     }     return rc; }

void CPluginChangeOrder_US::SetTradeReqData(int nCmdID, const Json::Value &jsnVal, SOCKET sock){	CHECK_RET(nCmdID == PROTO_ID_QUOTE && sock != INVALID_SOCKET, NORET);	CHECK_RET(m_pTradeOp && m_pTradeServer, NORET);	CProtoQuote proto;	CProtoQuote::ProtoReqDataType	req;	proto.SetProtoData_Req(&req);	if ( !proto.ParseJson_Req(jsnVal) )	{		CHECK_OP(false, NORET);		return;	}	CHECK_RET(req.head.nProtoID == nCmdID && req.body.nCookie, NORET);	ChangeOrderReqBody &body = req.body;			StockDataReq *pReq = new StockDataReq;	CHECK_RET(pReq, NORET);	pReq->sock = sock;	pReq->dwReqTick = ::GetTickCount();	pReq->req = req; 	pReq->bWaitDelaySvrID = true; 	DoTryProcessTradeOpt(pReq); }

U2VariantTrack MysqlVariantDbi::getVariantTrack(const U2DataId& variantTrackId, U2OpStatus& os) {    U2VariantTrack res;    DBI_TYPE_CHECK(variantTrackId, U2Type::VariantTrack, os, res);    MysqlTransaction t(db, os);    Q_UNUSED(t);    dbi->getMysqlObjectDbi()->getObject(res, variantTrackId, os);    CHECK_OP(os, res);    static const QString queryString = "SELECT sequence, sequenceName, trackType, fileHeader FROM VariantTrack WHERE object = :object";    U2SqlQuery q(queryString, db, os);    q.bindDataId(":object", variantTrackId);    if (q.step()) {        res.sequence = q.getDataId(0, U2Type::Sequence);        res.sequenceName = q.getString(1);        int trackType = q.getInt32(2);        CHECK_EXT(TrackType_FIRST <= trackType && trackType <= TrackType_LAST,                  os.setError(U2DbiL10n::tr("Invalid variant track type: %1").arg(trackType)), res);        res.trackType = static_cast<VariantTrackType>(trackType);        res.fileHeader = q.getString(3);        q.ensureDone();    }    return res;}

QList<Task*> AceImporterTask::onSubTaskFinished(Task* subTask) {    QList<Task*> res;    CHECK_OP(stateInfo, res);    if (isSqliteDbTransit && convertTask == subTask) {        initCloneObjectTasks();        res << cloneTasks;    }    else if (isSqliteDbTransit && cloneTasks.contains(subTask)) {        cloneTasks.removeOne(subTask);        if (cloneTasks.isEmpty()) {            initLoadDocumentTask();            CHECK(NULL != loadDocTask, res);            res << loadDocTask;        }    }    else if (!isSqliteDbTransit && convertTask == subTask) {        initLoadDocumentTask();        CHECK(NULL != loadDocTask, res);        res << loadDocTask;    }    if (loadDocTask == subTask) {        resultDocument = loadDocTask->takeDocument();    }    return res;}

Task::ReportResult PairwiseAlignmentHirschbergTask::report() {    propagateSubtaskError();    CHECK_OP(stateInfo, ReportResult_Finished);    assert(kalignSubTask->inputMA.getNumRows() == kalignSubTask->resultMA.getNumRows());    return ReportResult_Finished;}

Task::ReportResult GTest_CalculateTreeFromAligment::report(){    if (task == NULL) {        return ReportResult_Finished;    }    if (!task->hasError()) {        PhyTree tree = task->getResult();        U2DbiRef dbiRef = AppContext::getDbiRegistry()->getSessionTmpDbiRef(stateInfo);        CHECK_OP(stateInfo, ReportResult_Finished);        PhyTreeObject *obj = PhyTreeObject::createInstance(tree, treeObjContextName, dbiRef, stateInfo);        CHECK_OP(stateInfo, ReportResult_Finished);        addContext(treeObjContextName,obj);    }    return ReportResult_Finished;}

QList<Task *> FindORFsToAnnotationsTask::onSubTaskFinished(Task *subTask) {    CHECK(subTask == fTask, QList<Task *>());    const QList<ORFFindResult> results = fTask->popResults();    QList<SharedAnnotationData> annotationList;    foreach (const ORFFindResult &res, results) {        CHECK_OP(stateInfo, QList<Task *>());        annotationList << res.toAnnotation(ORFAlgorithmSettings::ANNOTATION_GROUP_NAME);    }

U2Msa MAlignmentExporter::getAlignmentObject(const U2DbiRef &dbiRef, const U2DataId &msaId, U2OpStatus &os) const {    SAFE_POINT(!con.isOpen(), OPENED_DBI_CONNECTION_ERROR, U2Msa());    con.open(dbiRef, false, os);    U2Msa msa = exportAlignmentObject(msaId, os);    CHECK_OP(os, U2Msa());    return msa;}

BioStruct3DObject * BioStruct3DObject::createInstance(const BioStruct3D &bioStruct3D,    const QString &objectName, const U2DbiRef &dbiRef, U2OpStatus &os, const QVariantMap &hintsMap){    U2BioStruct3D object(dbiRef);    object.visualName = objectName;    object.serializer = BioStruct3DSerializer::ID;    const QString folder = hintsMap.value(DocumentFormat::DBI_FOLDER_HINT, U2ObjectDbi::ROOT_FOLDER).toString();    RawDataUdrSchema::createObject(dbiRef, folder, object, os);    CHECK_OP(os, NULL);    const U2EntityRef entRef(dbiRef, object.id);    const QByteArray data = BioStruct3DSerializer::serialize(bioStruct3D);    RawDataUdrSchema::writeContent(data, entRef, os);    CHECK_OP(os, NULL);    return new BioStruct3DObject(bioStruct3D, objectName, entRef, hintsMap);}

QList<Task*> DNASequenceGeneratorTask::onGenerateTaskFinished( ) {    QList<Task *> resultTasks;    SAFE_POINT( generateTask->isFinished( ) && !generateTask->getStateInfo( ).isCoR( ),        "Invalid task encountered", resultTasks );    IOAdapterFactory *iof = AppContext::getIOAdapterRegistry( )->getIOAdapterFactoryById(        IOAdapterUtils::url2io( cfg.getOutUrlString( ) ) );    if (cfg.saveDoc) {        DocumentFormat *format = AppContext::getDocumentFormatRegistry()->getFormatById(cfg.getDocumentFormatId());        Document* doc = format->createNewLoadedDocument(iof, cfg.getOutUrlString(), stateInfo);        CHECK_OP( stateInfo, resultTasks );        const QSet<QString> &supportedFormats = format->getSupportedObjectTypes( );        const bool isSequenceFormat = supportedFormats.contains( GObjectTypes::SEQUENCE );        if (  isSequenceFormat) {            addSequencesToSeqDoc( doc );        } else { // consider alignment format            SAFE_POINT( supportedFormats.contains( GObjectTypes::MULTIPLE_SEQUENCE_ALIGNMENT ),                "Unexpected format encountered", resultTasks );            addSequencesToMsaDoc( doc );        }        saveTask = new SaveDocumentTask(doc, SaveDoc_Overwrite);        resultTasks << saveTask;    } else { // TODO: avoid high memory consumption here        const DNAAlphabet *alp = cfg.getAlphabet( );        SAFE_POINT( NULL != alp, "Generated sequence has invalid alphabet", resultTasks );        const U2DbiRef dbiRef = generateTask->getDbiRef( );        const QString baseSeqName = cfg.getSequenceName( );        QList<U2Sequence> seqs = generateTask->getResults( );        for ( int sequenceNum = 0, totalSeqCount = seqs.size( ); sequenceNum < totalSeqCount;            ++sequenceNum )        {            const QString seqName = ( 1 < totalSeqCount )                ? ( baseSeqName + " " + QString::number( sequenceNum + 1 ) ) : baseSeqName;            DbiConnection con( dbiRef, stateInfo );            CHECK_OP( stateInfo, resultTasks );            const QByteArray seqContent = con.dbi->getSequenceDbi( )->getSequenceData(                seqs[sequenceNum].id, U2_REGION_MAX, stateInfo );            results << DNASequence( seqName, seqContent, alp );        }    }    return resultTasks;}

void CPluginChangeOrder_US::HandleTimeoutReq(){	if ( m_vtReqData.empty() )	{		SetTimerHandleTimeout(false);		return;	}	DWORD dwTickNow = ::GetTickCount();		VT_REQ_TRADE_DATA::iterator it_req = m_vtReqData.begin();	for ( ; it_req != m_vtReqData.end(); )	{		StockDataReq *pReq = *it_req;			if ( pReq == NULL )		{			CHECK_OP(false, NOOP);			++it_req;			continue;		}				//		if (pReq->bWaitDelaySvrID)		{			continue;;		}		if ( int(dwTickNow - pReq->dwReqTick) > 8000 )		{			TradeAckType ack;			ack.head = pReq->req.head;			ack.head.ddwErrCode= PROTO_ERR_SERVER_TIMEROUT;			CA::Unicode2UTF(L"协议超时", ack.head.strErrDesc);			//tomodify 5			ack.body.nEnvType = pReq->req.body.nEnvType;			ack.body.nCookie = pReq->req.body.nCookie;			ack.body.nSvrOrderID = pReq->req.body.nSvrOrderID;			ack.body.nLocalOrderID = pReq->req.body.nLocalOrderID;			ack.body.nSvrResult = Trade_SvrResult_Failed;			HandleTradeAck(&ack, pReq->sock);			it_req = m_vtReqData.erase(it_req);			delete pReq;		}		else		{			++it_req;		}	}	if ( m_vtReqData.empty() )	{		SetTimerHandleTimeout(false);		return;	}}

Task * AssemblyModel::createLoadReferenceAndAddToProjectTask(const U2CrossDatabaseReference& ref) {    QString url = ref.dataRef.dbiRef.dbiId;    U2OpStatus2Log os;    Document* refDoc = ObjectViewTask::createDocumentAndAddToProject(url, AppContext::getProject(), os);    CHECK_OP(os, NULL);    Task * t = new LoadUnloadedDocumentTask(refDoc);    return t;}

    UdrRecordId createObjectCore(UdrDbi *dbi, const QString& folder, U2RawData &object, U2OpStatus &os) {        dbi->createObject(RawDataUdrSchema::ID, object, folder, os);        CHECK_OP(os, UdrRecordId("", ""));        QList<UdrValue> data;        data << UdrValue(object.id);        data << UdrValue();        data << UdrValue(object.serializer);        return dbi->addRecord(RawDataUdrSchema::ID, data, os);    }

    UdrRecordId retrieveObject(UdrDbi *dbi, U2RawData &object, U2OpStatus &os) {        UdrRecordId recId = getRecordId(dbi, object.id, os);        CHECK_OP(os, recId);        UdrRecord record = dbi->getRecord(recId, os);        CHECK_OP(os, recId);        U2Object obj;        dbi->getRootDbi()->getObjectDbi()->getObject(obj, object.id, os);        CHECK_OP(os, recId);        object.visualName = obj.visualName;        object.version = obj.version;        CHECK_OP(os, recId);        object.serializer = record.getString(SERIALIZER, os);        CHECK_OP(os, recId);        return recId;    }

QWidget * BowtieWidgetController::createGUI(U2OpStatus &os) {    QScopedPointer<QWidget> result(new QWidget());    QVBoxLayout *vl = new QVBoxLayout();    vl->setContentsMargins(0, 0, 0, 0);    QHBoxLayout *hl = new QHBoxLayout(result.data());    hl->setContentsMargins(0, 0, 0, 0);    hl->addLayout(vl);    vl->addWidget(dirCtrl->createGUI(os));    CHECK_OP(os, NULL);    vl->addWidget(nameCtrl->createGUI(os));    CHECK_OP(os, NULL);    QPushButton *browseButton = new QPushButton(tr("Select/nbowtie index file"), result.data());    browseButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);    connect(browseButton, SIGNAL(clicked()), SLOT(sl_browse()));    hl->addWidget(browseButton);    return result.take();}

bool TestDbiProvider::init(const QString& dbiFileName, bool _useConnectionPool){    if(initialized){        close();        initialized = false;    }    TestRunnerSettings* trs = AppContext::getAppSettings()->getTestRunnerSettings();    QString originalFile = trs->getVar("COMMON_DATA_DIR") + "/" + dbiFileName;    QString tmpFile = QDir::temp().absoluteFilePath(QFileInfo(originalFile).fileName());    if(QFile::exists(tmpFile)) {        QFile::remove(tmpFile);    }    bool _create = false;    if (QFile::exists(originalFile)) {        SAFE_POINT(QFile::copy(originalFile, tmpFile), "db file not copied", false);    }else{        _create = true;    }    dbUrl = tmpFile;    useConnectionPool = _useConnectionPool;    U2DbiFactory *factory = AppContext::getDbiRegistry()->getDbiFactoryById(SQLITE_DBI_ID);    SAFE_POINT(factory!=NULL, "No dbi factory", false);    U2OpStatusImpl opStatus;    if(useConnectionPool){        U2DbiRef ref;        ref.dbiFactoryId = factory->getId();        ref.dbiId = dbUrl;        dbi = AppContext::getDbiRegistry()->getGlobalDbiPool()->openDbi(ref, _create, opStatus);        CHECK_OP(opStatus, false);    }else{        dbi = factory->createDbi();        SAFE_POINT(NULL != dbi, "dbi not created", false);        QHash<QString, QString> properties;        if(_create){           properties[U2DbiOptions::U2_DBI_OPTION_CREATE] = U2DbiOptions::U2_DBI_VALUE_ON;        }        properties["url"] = dbUrl;        QVariantMap persistentData;        dbi->init(properties, persistentData, opStatus);        SAFE_POINT_OP(opStatus, false);    }    U2ObjectDbi* objDbi = dbi->getObjectDbi();    SAFE_POINT(NULL != objDbi,  "object dbi not loaded", false);    initialized = true;    return true;}

//tomodify 5(数组等复杂结构或单层的结构体)bool CProtoGearPrice::MakeProtoBody_Req(Json::Value &jsnVal, const ProtoReqDataType &data){	CHECK_RET(warn_if_prop_exists(jsnVal, KEY_REQ_PARAM), false);	VT_PROTO_FIELD vtField;	GetProtoBodyField_Req(vtField, data.body);	Json::Value &jsnBody = jsnVal[KEY_REQ_PARAM];	bool bSuc = CProtoParseBase::MakeProtoFields(jsnBody, vtField);	CHECK_OP(bSuc, NOOP);	return bSuc;}