C++ (Cpp) CUOFsIpcMessageTranslator::ReadBlock Examples

Example #1

File: RuRefreshTaskExecutor.cpp Project: RuoYuHP/incubator-trafodion

//--------------------------------------------------------------------------//
//	CRUSingleTableLockProtocol::LoadDataFileNameList()
//--------------------------------------------------------------------------//
void CRUSingleTableLockProtocol::
  LoadDataFileNameList(CUOFsIpcMessageTranslator &translator)
{
  Int32 size;
  translator.ReadBlock(&size,sizeof(Int32));

  pUsedTblFileNameList_ = new CDSStringList();

  for (Int32 i=0;i<size;i++)
  {
    Int32 stringSize;
    const Int32 bufSize = CUOFsSystem::IpcMaxGuardianPathNameLength;
    char buf[bufSize];
		
    translator.ReadBlock(&stringSize, sizeof(Int32));
		
    RUASSERT(bufSize > stringSize);

#pragma nowarn(1506)   // warning elimination 
    translator.ReadBlock(buf, stringSize);
#pragma warn(1506)  // warning elimination 
		
    CDSString *objName = new CDSString(buf);

    pUsedTblFileNameList_->AddTail(objName);
  }
}

Example #2

File: RuUnAuditRefreshTaskExecutor.cpp Project: AlexPeng19/incubator-trafodion

void CRUUnAuditRefreshTaskExecutor::
	LoadRequest(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadRequest(translator);

	translator.ReadBlock(&isPurgedata_, sizeof(BOOL));
	translator.ReadBlock(&isPopindex_, sizeof(BOOL));

	// Store the executor-specific SQL container
	unAuditRefreshTEDynamicContainer_.LoadData(translator);

	translator.ReadBlock(&numOfIndexes_, sizeof(TInt32));

	if (0 < numOfIndexes_)
	{
		pUnAuditPopIndexdynamicContainer_ = 
#pragma nowarn(1506)   // warning elimination 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);
#pragma warn(1506)  // warning elimination 
		pUnAuditAvailableIndeXdynamicContainer_ =
#pragma nowarn(1506)   // warning elimination 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);
#pragma warn(1506)  // warning elimination 
		pUnAuditUnavailableIndeXdynamicContainer_ = 
#pragma nowarn(1506)   // warning elimination 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);
#pragma warn(1506)  // warning elimination 

		pUnAuditPopIndexdynamicContainer_->LoadData(translator);
		pUnAuditAvailableIndeXdynamicContainer_->LoadData(translator);
		pUnAuditUnavailableIndeXdynamicContainer_->LoadData(translator);
	}
}

Example #3

File: RuLogCleanupTaskExecutor.cpp Project: AlexPeng19/incubator-trafodion

//--------------------------------------------------------------------------//
//	CRULogCleanupTaskExecutor::LoadRequest()
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :cnu
void CRULogCleanupTaskExecutor::
	LoadRequest(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadRequest(translator);

	logCleanupTEDynamicContainer_.LoadData(translator);
	translator.ReadBlock(&hasRangeLog_,sizeof(BOOL));
	translator.ReadBlock(&noOfPartitions_,sizeof(Int32));
}

Example #4

File: RuRefreshTaskExecutor.cpp Project: RuoYuHP/incubator-trafodion

//--------------------------------------------------------------------------//
//	CRURefreshTaskExecutor::LoadReply()
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :cnu
void CRURefreshTaskExecutor::
	LoadReply(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadReply(translator);

	translator.ReadBlock(&isRecompute_,sizeof(BOOL));
}

Example #5

File: RuRefreshTaskExecutor.cpp Project: RuoYuHP/incubator-trafodion

//--------------------------------------------------------------------------//
//--------------------------------------------------------------------------//
void CRUSingleTableLockProtocol::LoadData(CUOFsIpcMessageTranslator &translator)
{
  LoadDataFileNameList(translator);

  pEmpCheck_ = new CRUEmpCheck();
  pEmpCheck_->LoadData(translator);

  translator.ReadBlock(&endEpoch_,sizeof(TInt32));
}

Example #6

File: RuEmpCheckVector.cpp Project: AlexPeng19/incubator-trafodion

void CRUEmpCheckVector::LoadData(CUOFsIpcMessageTranslator &translator)
{
	// Handle size_ data member
	translator.ReadBlock(&size_, sizeof(Lng32));

	// Handle final_ data member
	translator.ReadBlock(&isFinal_,sizeof(BOOL));

	if (NULL == pVec_)
	{
		pVec_ = new Elem[size_];
	}

	// Handle pVec_ data member
	for (Int32 i=0; i<size_; i++)
	{
		translator.ReadBlock(&(pVec_[i].epoch_),sizeof(TInt32));
		translator.ReadBlock(&(pVec_[i].checkBitmap_), sizeof(Lng32));
	}
}

Example #7

File: RuAuditRefreshTaskExecutor.cpp Project: AlexPeng19/incubator-trafodion

void CRUAuditRefreshTaskExecutor::
	LoadRequest(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadRequest(translator);

        translator.ReadBlock(&isPurgedata_, sizeof(BOOL));
	translator.ReadBlock(&isPopindex_, sizeof(BOOL));

	// Handle refresh executor sql dynamic container
	auditRefreshTEDynamicContainer_.LoadData(translator);
	
	// Handle isDeleteMultiTxnContext_ data member
	translator.ReadBlock(&isDeleteMultiTxnContext_,sizeof(BOOL));

        translator.ReadBlock(&numOfIndexes_, sizeof(TInt32));

	if (0 < numOfIndexes_)
	{
		pAuditPopIndexdynamicContainer_ =  
			new CRUSQLDynamicStatementContainer(numOfIndexes_);

		pAuditAvailableIndeXdynamicContainer_ =
			new CRUSQLDynamicStatementContainer(numOfIndexes_);

                pAuditUnavailableIndeXdynamicContainer_ = 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);

		pAuditToggleOnIndexdynamicContainer_ = 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);

		pAuditToggleOffIndexdynamicContainer_ = 
			new CRUSQLDynamicStatementContainer(numOfIndexes_);


		pAuditPopIndexdynamicContainer_->LoadData(translator);
		pAuditAvailableIndeXdynamicContainer_->LoadData(translator);
		pAuditUnavailableIndeXdynamicContainer_->LoadData(translator);
                pAuditToggleOnIndexdynamicContainer_->LoadData(translator);
                pAuditToggleOffIndexdynamicContainer_->LoadData(translator);
	}
}

Example #8

File: RuTableSyncTaskExecutor.cpp Project: AlexPeng19/incubator-trafodion

void CRUTableSyncTaskExecutor::
	LoadRequest(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadRequest(translator);

	Int32 stringSize;
	Int32 const maxStringSize = CUOFsIpcMessageTranslator::MaxMsgSize;
	char buffer[maxStringSize];

	translator.ReadBlock(&stringSize, sizeof(Int32));
	
	RUASSERT(maxStringSize > stringSize);

#pragma nowarn(1506)   // warning elimination 
	translator.ReadBlock(buffer, stringSize);
#pragma warn(1506)  // warning elimination 
	
	tableName_ = CDSString(buffer);

	syncTableDynamicContainer_.LoadData(translator);
}

Example #9

File: RuEmpCheck.cpp Project: AlexPeng19/incubator-trafodion

void CRUEmpCheck::LoadData(CUOFsIpcMessageTranslator &translator)
{
	pSQLContainer_->LoadData(translator);

	if (NULL == pVec_)
	{
		pVec_ = new CRUEmpCheckVector();
	}
	
	pVec_->LoadData(translator);

	translator.ReadBlock(&checkMask_, sizeof(Lng32));
}

Example #10

File: RuRefreshTaskExecutor.cpp Project: RuoYuHP/incubator-trafodion

//--------------------------------------------------------------------------//
//	CRUTableLockProtocol::LoadData()
//
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :cnu
void CRUTableLockProtocol::LoadData(CUOFsIpcMessageTranslator &translator)
{
  // Load the NothingToLock_ flag
  translator.ReadBlock(&NothingToLock_, sizeof(BOOL));
  if (NothingToLock_)
    return;

  // Load the number of elements in the lock list
  Lng32 count;
  translator.ReadBlock(&count, sizeof(Lng32));

  // Load the lock elements.
  LocksList_ = new LocksList();
  for (Lng32 i=0; i<count; i++)
  {
    // Alloc a new lock object, init it and add it to the list.
    CRUSingleTableLockProtocol *thisLock = new CRUSingleTableLockProtocol();
    thisLock->LoadData(translator);
    LocksList_->AddTail(thisLock);

  }

}

Example #11

File: RuSQLDynamicStatementContainer.cpp Project: RuoYuHP/incubator-trafodion

void CRUSQLDynamicStatementContainer::DynamicStmt::
	LoadData(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadData(translator);

	short size;
	translator.ReadBlock(&size,sizeof(short));

	if (0 == size)
	{
		return;
	}

	translator.ReadBlock(&paramNum_, sizeof(Lng32));

	for (Int32 i=0;i<paramNum_;i++)
	{
		translator.ReadBlock(&(paramsPos_[i]), sizeof(Int32));
	}

	sql_ = new char[size];

	translator.ReadBlock(sql_,size);
}

Example #12

File: RuRefreshTaskExecutor.cpp Project: RuoYuHP/incubator-trafodion

//--------------------------------------------------------------------------//
//	CRURefreshTaskExecutor::LoadRequest()
//--------------------------------------------------------------------------//
// LCOV_EXCL_START :cnu
void CRURefreshTaskExecutor::
	LoadRequest(CUOFsIpcMessageTranslator &translator)
{
	inherited::LoadRequest(translator);

	translator.ReadBlock(&isRecompute_,sizeof(BOOL));

	Int32 stringSize;
	char buffer[CUOFsIpcMessageTranslator::MaxMsgSize];

	translator.ReadBlock(&stringSize, sizeof(Int32));
#pragma nowarn(1506)   // warning elimination 
	translator.ReadBlock(buffer, stringSize);
#pragma warn(1506)  // warning elimination 

	rootMVName_ = CDSString(buffer);

	translator.ReadBlock(&stringSize, sizeof(Int32));
#pragma nowarn(1506)   // warning elimination 
	translator.ReadBlock(buffer, stringSize);
#pragma warn(1506)  // warning elimination 

	rootMVSchema_ = CDSString(buffer);

	translator.ReadBlock(&stringSize, sizeof(Int32));
#pragma nowarn(1506)   // warning elimination 
	translator.ReadBlock(buffer, stringSize);
#pragma warn(1506)  // warning elimination 

	rootMVCatalog_ = CDSString(buffer);
	
	translator.ReadBlock(&rootMVUID_, sizeof(TInt64));
	
	translator.ReadBlock(&rootMVType_, sizeof(Int32));

	translator.ReadBlock(&forceFlags_, sizeof(TInt32));

	if (NO_FORCE != forceFlags_)
	{
		translator.ReadBlock(&numOfStmtInContainer_, sizeof(TInt32));
		
		pRefreshTEDynamicContainer_ = 
#pragma nowarn(1506)   // warning elimination 
			new CRUSQLDynamicStatementContainer(numOfStmtInContainer_);		
#pragma warn(1506)  // warning elimination 
		// Handle refresh executor sql dynamic container
		pRefreshTEDynamicContainer_->LoadData(translator);
	}
	
	// Handle lock table dynamic container
	short lockTable;
	translator.ReadBlock(&lockTable, sizeof(short));
	
	if (1 == lockTable)
	{
	  tableLockProtocol_ = new CRUTableLockProtocol();
	  tableLockProtocol_->LoadData(translator);
	}
}