XnStatus XnDeviceBase::BatchConfig(const XnPropertySet* pChangeSet)
{
XnStatus nRetVal = XN_STATUS_OK;
XN_VALIDATE_INPUT_PTR(pChangeSet);
// start a transaction
nRetVal = StartTransaction();
XN_IS_STATUS_OK(nRetVal);
for (XnPropertySetData::ConstIterator itModule = pChangeSet->pData->begin(); itModule != pChangeSet->pData->end(); ++itModule)
{
// find this module
XnDeviceModule* pModule = NULL;
nRetVal = FindModule(itModule.Key(), &pModule);
XN_CHECK_RC_ROLLBACK(nRetVal);
nRetVal = pModule->BatchConfig(*itModule.Value());
XN_CHECK_RC_ROLLBACK(nRetVal);
}
nRetVal = CommitTransaction();
XN_IS_STATUS_OK(nRetVal);
return (XN_STATUS_OK);
}
//---------------------------------------------------------------------------
// Register the interface to be tested. This function registers the
// interface to be tested. It has to be called right after Init() and
// before any other methods are called
//
// For testing Data Source, DB Session, and Command objects, no properties
// need be specified. For testing rowset objects, the array of properties
// to be set for the rowset, the IID_Interface in particular, has to be
// specified unless the interface is mandatory.
//
// @mfunc RegisterInterface
//
// @rdesc Success or Failure
// @flag TRUE | The Interface is supported by the provider.
// @flag FALSE | he Interface is not supported by the provider.
//
//---------------------------------------------------------------------------
BOOL CTransaction::RegisterInterface(
EINTERFACE eInterface, //@parm [in] the ole db object to be tested
IID iid, //@parm [in] the interface to be tested
ULONG cPropSets, //@parm[in] the count of DBPROPSET structures to be set
DBPROPSET * rgPropSets //@parm[in] the array of DBPROPSET structures to be set
)
{
BOOL fSupported = TRUE;
// Copy the information about the OLE DB object and interface
m_eInterface = eInterface;
m_iid = iid;
// The interface is not supported if we can not created a transaction that return
// a pointer to the requested interface
if (!StartTransaction(SELECT_ALLFROMTBL,NULL,cPropSets,rgPropSets))
{
// Reset m_iid to IID_IUnknown as a flag
m_iid=IID_IUnknown;
odtLog<<wszInterfaceNotSupported;
fSupported=FALSE;
}
CleanUpTransaction(S_OK);
return fSupported;
}
void ezQtPropertyAnimAssetDocumentWindow::onRebindSelectedItems()
{
auto pDoc = GetPropertyAnimDocument();
auto pHistory = pDoc->GetCommandHistory();
ezHybridArray<ezUuid, 16> rebindTracks;
for (ezInt32 iTrack : m_MapSelectionToTrack)
{
const ezVariant trackGuid = pDoc->GetPropertyObject()->GetTypeAccessor().GetValue("Tracks", iTrack);
if (trackGuid.IsValid())
rebindTracks.PushBack(trackGuid.Get<ezUuid>());
}
if (m_iMapGradientToTrack >= 0)
{
const ezVariant trackGuid = pDoc->GetPropertyObject()->GetTypeAccessor().GetValue("Tracks", m_iMapGradientToTrack);
if (trackGuid.IsValid())
rebindTracks.PushBack(trackGuid.Get<ezUuid>());
}
bool ok = false;
QString result = QInputDialog::getText(this, "Change Animation Binding", "New Binding Path:", QLineEdit::Normal, "", &ok);
if (!ok)
return;
m_pSelectionModel->clear();
ezStringBuilder path = result.toUtf8().data();
;
path.MakeCleanPath();
const ezVariant varRes = path.GetData();
pHistory->StartTransaction("Rebind Tracks");
for (const ezUuid guid : rebindTracks)
{
ezSetObjectPropertyCommand cmdSet;
cmdSet.m_Object = guid;
cmdSet.m_sProperty = "ObjectPath";
cmdSet.m_NewValue = varRes;
pDoc->GetCommandHistory()->AddCommand(cmdSet);
}
pHistory->FinishTransaction();
}
void ezQtPropertyAnimAssetDocumentWindow::onDeleteSelectedItems()
{
auto pDoc = GetPropertyAnimDocument();
auto pHistory = pDoc->GetCommandHistory();
pHistory->StartTransaction("Delete Tracks");
m_pGradientToDisplay = nullptr;
m_CurvesToDisplay.Clear();
// delete the tracks with the highest index first, otherwise the lower indices become invalid
// do this before modifying anything, as m_MapSelectionToTrack will change once the remove commands are executed
ezHybridArray<ezInt32, 16> sortedTrackIDs;
{
for (ezInt32 iTrack : m_MapSelectionToTrack)
{
sortedTrackIDs.PushBack(iTrack);
}
if (m_iMapGradientToTrack >= 0)
{
sortedTrackIDs.PushBack(m_iMapGradientToTrack);
}
sortedTrackIDs.Sort();
}
for (ezUInt32 i = sortedTrackIDs.GetCount(); i > 0; --i)
{
const ezInt32 iTrack = sortedTrackIDs[i - 1];
const ezVariant trackGuid = pDoc->GetPropertyObject()->GetTypeAccessor().GetValue("Tracks", iTrack);
if (trackGuid.IsValid())
{
ezRemoveObjectCommand cmd;
cmd.m_Object = trackGuid.Get<ezUuid>();
pHistory->AddCommand(cmd);
}
}
m_MapSelectionToTrack.Clear();
m_iMapGradientToTrack = -1;
pHistory->FinishTransaction();
}
boolean CDWHCIDevice::TransferStageAsync (CUSBRequest *pURB, boolean bIn, boolean bStatusStage)
{
assert (pURB != 0);
unsigned nChannel = AllocateChannel ();
if (nChannel >= m_nChannels)
{
return FALSE;
}
CDWHCITransferStageData *pStageData =
new CDWHCITransferStageData (nChannel, pURB, bIn, bStatusStage);
assert (pStageData != 0);
assert (m_pStageData[nChannel] == 0);
m_pStageData[nChannel] = pStageData;
EnableChannelInterrupt (nChannel);
if (!pStageData->IsSplit ())
{
pStageData->SetState (StageStateNoSplitTransfer);
}
else
{
if (!pStageData->BeginSplitCycle ())
{
DisableChannelInterrupt (nChannel);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
return FALSE;
}
pStageData->SetState (StageStateStartSplit);
pStageData->SetSplitComplete (FALSE);
pStageData->GetFrameScheduler ()->StartSplit ();
}
StartTransaction (pStageData);
return TRUE;
}
void output_ogr(const std::string& filename, const std::string& driver_name, const segvec& removed_segments, const segvec& added_segments) {
OGRRegisterAll();
OGRSFDriver* driver = OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str());
if (!driver) {
std::cerr << driver_name << " driver not available.\n";
exit(return_code_fatal);
}
//const char* options[] = { "SPATIALITE=yes", "OGR_SQLITE_SYNCHRONOUS=OFF", "INIT_WITH_EPSG=no", nullptr };
const char* options[] = { nullptr };
auto data_source = std::unique_ptr<OGRDataSource, OGRDataSourceDestroyer>(driver->CreateDataSource(filename.c_str(), const_cast<char**>(options)));
if (!data_source) {
std::cerr << "Creation of output file failed.\n";
exit(return_code_fatal);
}
SRS srs;
auto layer = data_source->CreateLayer("changes", srs.out(), wkbLineString, const_cast<char**>(options));
if (!layer) {
std::cerr << "Creating layer 'changes' failed.\n";
exit(return_code_fatal);
}
OGRFieldDefn field_change("change", OFTInteger);
field_change.SetWidth(1);
if (layer->CreateField(&field_change) != OGRERR_NONE ) {
std::cerr << "Creating field 'change' on 'changes' layer failed.\n";
exit(return_code_fatal);
}
layer->StartTransaction();
for (const auto& segment : removed_segments) {
add_segment(layer, 0, segment);
}
for (const auto& segment : added_segments) {
add_segment(layer, 1, segment);
}
layer->CommitTransaction();
}
void CDWHCIDevice::TimerHandler (CDWHCITransferStageData *pStageData)
{
DataMemBarrier ();
assert (pStageData != 0);
assert (pStageData->GetState () == StageStatePeriodicDelay);
if (pStageData->IsSplit ())
{
pStageData->SetState (StageStateStartSplit);
pStageData->SetSplitComplete (FALSE);
pStageData->GetFrameScheduler ()->StartSplit ();
}
else
{
pStageData->SetState (StageStateNoSplitTransfer);
}
StartTransaction (pStageData);
DataMemBarrier ();
}
void CDWHCIDevice::ChannelInterruptHandler (unsigned nChannel)
{
CDWHCITransferStageData *pStageData = m_pStageData[nChannel];
assert (pStageData != 0);
CUSBRequest *pURB = pStageData->GetURB ();
assert (pURB != 0);
switch (pStageData->GetSubState ())
{
case StageSubStateWaitForChannelDisable:
StartChannel (pStageData);
return;
case StageSubStateWaitForTransactionComplete: {
CleanDataCache ();
InvalidateDataCache ();
DataMemBarrier ();
CDWHCIRegister TransferSize (DWHCI_HOST_CHAN_XFER_SIZ (nChannel));
TransferSize.Read ();
CDWHCIRegister ChanInterrupt (DWHCI_HOST_CHAN_INT (nChannel));
assert ( !pStageData->IsPeriodic ()
|| DWHCI_HOST_CHAN_XFER_SIZ_PID (TransferSize.Get ())
!= DWHCI_HOST_CHAN_XFER_SIZ_PID_MDATA);
pStageData->TransactionComplete (ChanInterrupt.Read (),
DWHCI_HOST_CHAN_XFER_SIZ_PACKETS (TransferSize.Get ()),
TransferSize.Get () & DWHCI_HOST_CHAN_XFER_SIZ_BYTES__MASK);
} break;
default:
assert (0);
break;
}
unsigned nStatus;
switch (pStageData->GetState ())
{
case StageStateNoSplitTransfer:
nStatus = pStageData->GetTransactionStatus ();
if (nStatus & DWHCI_HOST_CHAN_INT_ERROR_MASK)
{
CLogger::Get ()->Write (FromDWHCI, LogError,
"Transaction failed (status 0x%X)", nStatus);
pURB->SetStatus (0);
}
else if ( (nStatus & (DWHCI_HOST_CHAN_INT_NAK | DWHCI_HOST_CHAN_INT_NYET))
&& pStageData->IsPeriodic ())
{
pStageData->SetState (StageStatePeriodicDelay);
unsigned nInterval = pURB->GetEndpoint ()->GetInterval ();
m_pTimer->StartKernelTimer (MSEC2HZ (nInterval), TimerStub, pStageData, this);
break;
}
else
{
if (!pStageData->IsStatusStage ())
{
pURB->SetResultLen (pStageData->GetResultLen ());
}
pURB->SetStatus (1);
}
DisableChannelInterrupt (nChannel);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
pURB->CallCompletionRoutine ();
break;
case StageStateStartSplit:
nStatus = pStageData->GetTransactionStatus ();
if ( (nStatus & DWHCI_HOST_CHAN_INT_ERROR_MASK)
|| (nStatus & DWHCI_HOST_CHAN_INT_NAK)
|| (nStatus & DWHCI_HOST_CHAN_INT_NYET))
{
CLogger::Get ()->Write (FromDWHCI, LogError,
"Transaction failed (status 0x%X)", nStatus);
pURB->SetStatus (0);
DisableChannelInterrupt (nChannel);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
pURB->CallCompletionRoutine ();
break;
}
pStageData->GetFrameScheduler ()->TransactionComplete (nStatus);
pStageData->SetState (StageStateCompleteSplit);
pStageData->SetSplitComplete (TRUE);
if (!pStageData->GetFrameScheduler ()->CompleteSplit ())
{
goto LeaveCompleteSplit;
}
StartTransaction (pStageData);
break;
case StageStateCompleteSplit:
nStatus = pStageData->GetTransactionStatus ();
if (nStatus & DWHCI_HOST_CHAN_INT_ERROR_MASK)
{
CLogger::Get ()->Write (FromDWHCI, LogError,
"Transaction failed (status 0x%X)", nStatus);
pURB->SetStatus (0);
DisableChannelInterrupt (nChannel);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
pURB->CallCompletionRoutine ();
break;
}
pStageData->GetFrameScheduler ()->TransactionComplete (nStatus);
if (pStageData->GetFrameScheduler ()->CompleteSplit ())
{
StartTransaction (pStageData);
break;
}
LeaveCompleteSplit:
if (!pStageData->IsStageComplete ())
{
if (!pStageData->BeginSplitCycle ())
{
pURB->SetStatus (0);
DisableChannelInterrupt (nChannel);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
pURB->CallCompletionRoutine ();
break;
}
if (!pStageData->IsPeriodic ())
{
pStageData->SetState (StageStateStartSplit);
pStageData->SetSplitComplete (FALSE);
pStageData->GetFrameScheduler ()->StartSplit ();
StartTransaction (pStageData);
}
else
{
pStageData->SetState (StageStatePeriodicDelay);
unsigned nInterval = pURB->GetEndpoint ()->GetInterval ();
m_pTimer->StartKernelTimer (MSEC2HZ (nInterval),
TimerStub, pStageData, this);
}
break;
}
DisableChannelInterrupt (nChannel);
if (!pStageData->IsStatusStage ())
{
pURB->SetResultLen (pStageData->GetResultLen ());
}
pURB->SetStatus (1);
delete pStageData;
m_pStageData[nChannel] = 0;
FreeChannel (nChannel);
pURB->CallCompletionRoutine ();
break;
default:
assert (0);
break;
}
}
OGRLayer *
OGRPGDumpDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
CPLString osCommand;
const char *pszGeomType = NULL;
char *pszLayerName = NULL;
const char *pszTableName = NULL;
char *pszSchemaName = NULL;
int nDimension = 3;
const char *pszFIDColumn = "OGC_FID";
int bHavePostGIS = TRUE;
if (pszLayerNameIn == NULL)
return NULL;
if (strncmp(pszLayerNameIn, "pg", 2) == 0)
{
CPLError(CE_Warning, CPLE_AppDefined,
"The layer name should not begin by 'pg' as it is a reserved prefix");
}
//bHavePostGIS = CSLFetchBoolean(papszOptions,"POSTGIS", TRUE);
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
{
pszLayerName = LaunderName( pszLayerNameIn );
}
else
pszLayerName = CPLStrdup( pszLayerNameIn );
int bCreateTable = CSLFetchBoolean(papszOptions,"CREATE_TABLE", TRUE);
if (eType == wkbNone)
bHavePostGIS = FALSE;
else if( wkbFlatten(eType) == eType )
nDimension = 2;
if( CSLFetchNameValue( papszOptions, "DIM") != NULL )
nDimension = atoi(CSLFetchNameValue( papszOptions, "DIM"));
/* Postgres Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema == current_schema()
Usage without schema name is backwards compatible
*/
pszTableName = strstr(pszLayerName,".");
if ( pszTableName != NULL )
{
int length = pszTableName - pszLayerName;
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
++pszTableName; //skip "."
}
else
{
pszSchemaName = NULL;
pszTableName = pszLayerName;
}
Commit();
/* -------------------------------------------------------------------- */
/* Set the default schema for the layers. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
osCommand.Printf("CREATE SCHEMA \"%s\"", pszSchemaName);
Log(osCommand);
}
if ( pszSchemaName == NULL)
{
pszSchemaName = CPLStrdup("public");
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n",
pszLayerName );
CPLFree( pszLayerName );
CPLFree( pszSchemaName );
return NULL;
}
}
if (bCreateTable)
{
osCommand.Printf("DROP TABLE \"%s\".\"%s\" CASCADE", pszSchemaName, pszTableName );
Log(osCommand);
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( pszGeomType == NULL )
{
pszGeomType = "geometry";
}
if( !EQUAL(pszGeomType,"geometry") && !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"GEOM_TYPE in PostGIS enabled databases must be 'geometry' or 'geography'.\n"
"Creation of layer %s with GEOM_TYPE %s has failed.",
pszLayerName, pszGeomType );
CPLFree( pszLayerName );
CPLFree( pszSchemaName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
else
{
if (poSRS)
{
const char* pszAuthorityName = poSRS->GetAuthorityName(NULL);
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* Assume the EPSG Id is the SRS ID. Might be a wrong guess ! */
nSRSId = atoi( poSRS->GetAuthorityCode(NULL) );
}
else
{
const char* pszGeogCSName = poSRS->GetAttrValue("GEOGCS");
if (pszGeogCSName != NULL && EQUAL(pszGeogCSName, "GCS_WGS_1984"))
nSRSId = 4326;
}
}
}
const char *pszGeometryType = OGRToOGCGeomType(eType);
const char *pszGFldName = NULL;
if( bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
if( CSLFetchNameValue( papszOptions, "GEOMETRY_NAME") != NULL )
pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
else
pszGFldName = "wkb_geometry";
/* Sometimes there is an old cruft entry in the geometry_columns
* table if things were not properly cleaned up before. We make
* an effort to clean out such cruft.
*/
osCommand.Printf(
"DELETE FROM geometry_columns WHERE f_table_name = '%s' AND f_table_schema = '%s'",
pszTableName, pszSchemaName );
if (bCreateTable)
Log(osCommand);
}
StartTransaction();
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
CPLString osCreateTable;
int bTemporary = CSLFetchNameValue( papszOptions, "TEMPORARY" ) != NULL &&
CSLTestBoolean(CSLFetchNameValue( papszOptions, "TEMPORARY" ));
if (bTemporary)
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup("pg_temp_1");
osCreateTable.Printf("CREATE TEMPORARY TABLE \"%s\"", pszTableName);
}
else
osCreateTable.Printf("CREATE TABLE \"%s\".\"%s\"", pszSchemaName, pszTableName);
if( !bHavePostGIS )
{
if (eType == wkbNone)
osCommand.Printf(
"%s ( "
" %s SERIAL, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), pszFIDColumn, pszTableName, pszFIDColumn );
else
osCommand.Printf(
"%s ( "
" %s SERIAL, "
" WKB_GEOMETRY %s, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), pszFIDColumn, pszGeomType, pszTableName, pszFIDColumn );
}
else if ( EQUAL(pszGeomType, "geography") )
{
if( CSLFetchNameValue( papszOptions, "GEOMETRY_NAME") != NULL )
pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
else
pszGFldName = "the_geog";
if (nSRSId)
osCommand.Printf(
"%s ( %s SERIAL, \"%s\" geography(%s%s,%d), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), pszFIDColumn, pszGFldName, pszGeometryType, nDimension == 2 ? "" : "Z", nSRSId, pszTableName, pszFIDColumn );
else
osCommand.Printf(
"%s ( %s SERIAL, \"%s\" geography(%s%s), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), pszFIDColumn, pszGFldName, pszGeometryType, nDimension == 2 ? "" : "Z", pszTableName, pszFIDColumn );
}
else
{
osCommand.Printf(
"%s ( %s SERIAL, CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), pszFIDColumn, pszTableName, pszFIDColumn );
}
if (bCreateTable)
Log(osCommand);
/* -------------------------------------------------------------------- */
/* Eventually we should be adding this table to a table of */
/* "geometric layers", capturing the WKT projection, and */
/* perhaps some other housekeeping. */
/* -------------------------------------------------------------------- */
if( bCreateTable && bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
osCommand.Printf(
"SELECT AddGeometryColumn('%s','%s','%s',%d,'%s',%d)",
pszSchemaName, pszTableName, pszGFldName,
nSRSId, pszGeometryType, nDimension );
Log(osCommand);
}
if( bCreateTable && bHavePostGIS )
{
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
if( pszSI == NULL || CSLTestBoolean(pszSI) )
{
osCommand.Printf("CREATE INDEX \"%s_geom_idx\" "
"ON \"%s\".\"%s\" "
"USING GIST (\"%s\")",
pszTableName, pszSchemaName, pszTableName, pszGFldName);
Log(osCommand);
}
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRPGDumpLayer *poLayer;
int bWriteAsHex = !CSLFetchBoolean(papszOptions,"WRITE_EWKT_GEOM",FALSE);
poLayer = new OGRPGDumpLayer( this, pszSchemaName, pszLayerName, pszGFldName,
pszFIDColumn, nDimension, nSRSId, bWriteAsHex, bCreateTable );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRPGDumpLayer **)
CPLRealloc( papoLayers, sizeof(OGRPGDumpLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
CPLFree( pszSchemaName );
return poLayer;
}
/*
* StartTransactionCommand
*/
void
StartTransactionCommand(void)
{
TransactionState s = CurrentTransactionState;
switch (s->blockState)
{
/*
* if we aren't in a transaction block, we just do our usual
* start transaction.
*/
case TBLOCK_DEFAULT:
StartTransaction();
break;
/*
* We should never experience this -- if we do it means the
* BEGIN state was not changed in the previous
* CommitTransactionCommand(). If we get it, we print a
* warning and change to the in-progress state.
*/
case TBLOCK_BEGIN:
elog(WARNING, "StartTransactionCommand: unexpected TBLOCK_BEGIN");
s->blockState = TBLOCK_INPROGRESS;
break;
/*
* This is the case when are somewhere in a transaction block
* and about to start a new command. For now we do nothing
* but someday we may do command-local resource
* initialization.
*/
case TBLOCK_INPROGRESS:
break;
/*
* As with BEGIN, we should never experience this if we do it
* means the END state was not changed in the previous
* CommitTransactionCommand(). If we get it, we print a
* warning, commit the transaction, start a new transaction
* and change to the default state.
*/
case TBLOCK_END:
elog(WARNING, "StartTransactionCommand: unexpected TBLOCK_END");
s->blockState = TBLOCK_DEFAULT;
CommitTransaction();
StartTransaction();
break;
/*
* Here we are in the middle of a transaction block but one of
* the commands caused an abort so we do nothing but remain in
* the abort state. Eventually we will get to the "END
* TRANSACTION" which will set things straight.
*/
case TBLOCK_ABORT:
break;
/*
* This means we somehow aborted and the last call to
* CommitTransactionCommand() didn't clear the state so we
* remain in the ENDABORT state and maybe next time we get to
* CommitTransactionCommand() the state will get reset to
* default.
*/
case TBLOCK_ENDABORT:
elog(WARNING, "StartTransactionCommand: unexpected TBLOCK_ENDABORT");
break;
}
/*
* We must switch to TopTransactionContext before returning. This is
* already done if we called StartTransaction, otherwise not.
*/
Assert(TopTransactionContext != NULL);
MemoryContextSwitchTo(TopTransactionContext);
}
TInt CIdWsfAuthenticationServiceClient::ValidateL(
CIdWsfServiceSession &aSession,
const TDesC8& /*authnContext*/,
MSenRemoteServiceConsumer& aRemoteConsumer)
{
CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfAuthenticationServiceClient::ValidateL(..)");
// keep this as first line
iServedConsumer = &aRemoteConsumer;
if(!ipAccount)
{
return KErrSenNoEndpoint;
}
TInt retVal(KErrNone); // for returning error codes
iCState = EAuthServiceClient; // set state
iDsSession = &aSession; // save session
CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"- starting transaction.");
StartTransaction();
TPtrC8 mechanismNames =
Framework().Manager().SenSecurityMechanismNames8L();
CIdWsfSaslMessage* pInitMessage =
CIdWsfSaslMessage::NewL(Framework().Manager(),
KSaslXmlns,
KSaslRequestName,
KSaslRequestQName);
CleanupStack::PushL(pInitMessage); // push pInitMessage
CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"- constructing initial request.");
pInitMessage->ConstructInitRequestFromL(mechanismNames, *ipAccount);
HBufC8* pInitRequest8 = pInitMessage->AsXmlL();
CleanupStack::PushL(pInitRequest8); // push pInitRequest
if(iService)
{
HBufC8* pResponse8 = NULL;
HBufC8* pNextMessage = NULL;
#ifdef _SENDEBUG
TPtr8 initRequest = pInitRequest8->Des();
//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("AS_init_req.xml"), initRequest);
#endif // _SENDEBUG
retVal = iService->SubmitL(*pInitRequest8, KNullDesC8, *this, pResponse8);
aRemoteConsumer.SetDataTrafficDetails(iAuthDetails);
CleanupStack::PushL(pResponse8); // pResponse8
if(retVal == KErrNone && pResponse8)
{
#ifdef _SENDEBUG
TPtr8 initResponse = pResponse8->Des();
//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("AS_init_rsp.xml"), initResponse);
#endif // _SENDEBUG
retVal = ParseResponseL(*pResponse8, pNextMessage);
}
#ifdef _SENDEBUG
else
{
CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"CIdWsfAuthenticationServiceClient::ValidateL:");
CSLOG_FORMAT((aRemoteConsumer.ConnectionId(), KMinLogLevel , _L8("- SubmitL failed: %d"), retVal));
}
#endif // _SENDEBUG
CleanupStack::PopAndDestroy(1); // pResponse8
while ( pNextMessage )
{
#ifdef _SENDEBUG
TPtr8 authRequest = pNextMessage->Des();
//wslog FILELOGALL(_L("SenCoreServiceManager"), _L("AS_req.xml"), authRequest);
#endif // _SENDEBUG
CleanupStack::PushL(pNextMessage); // pNextMessage
retVal = iService->SubmitL(*pNextMessage, KNullDesC8, *this, pResponse8);
aRemoteConsumer.SetDataTrafficDetails(iAuthDetails);
CleanupStack::PopAndDestroy(); // pNextMessage
pNextMessage = NULL;
if (retVal == KErrNone && pResponse8)
{
CleanupStack::PushL(pResponse8); // pResponse8
#ifdef _SENDEBUG
TPtr8 authResponse = pResponse8->Des();
//wslog FILELOGALL(_L("WsLog"), _L("AS_rsp.xml"), authResponse);
#endif // _SENDEBUG
retVal = ParseResponseL(*pResponse8, pNextMessage);
CleanupStack::PopAndDestroy(); // pResponse8
}
}
}
CleanupStack::PopAndDestroy(2); // pInitRequest8, pInitMessage
if ((retVal == KErrNone) && iDsSession->IsReadyL())
{
CSLOG_L(aRemoteConsumer.ConnectionId(), KMinLogLevel ,"- starting transaction.");
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel ,"- setting validator for DS session.");
iDsSession->SetValidator(this);
}
return retVal;
}
