void FdoPropertyDefinitionCollection::RemoveAt(FdoInt32 index)
{
    FdoSchemaElement*   item = NULL;
    FdoSchemaElement*   parent = NULL;

    try
    {
        item = GetItem(index);
        if (item)
            parent = item->GetParent();

        FdoSchemaCollection<FdoPropertyDefinition>::RemoveAt(index);

        if (parent)
        {
            if (!(m_changeInfoState & CHANGEINFO_PROCESSING)) // don't notify during Accept/RejectChanges()
                parent->PropertyRemoved((const FdoPropertyDefinition*)item);
            FDO_SAFE_RELEASE(parent);
        }
    }
    catch (FdoException* pExcept)
    {
        FDO_SAFE_RELEASE(parent);
        FDO_SAFE_RELEASE(item);
        throw pExcept;
    }

    FDO_SAFE_RELEASE(item);
}
FdoReadOnlyPropertyDefinitionCollection::FdoReadOnlyPropertyDefinitionCollection(FdoPropertyDefinitionCollection* properties)
{
    FdoIDisposable*   item = NULL;
    FdoIDisposableCollection*   collection = NULL;

    if (properties)
    {
        try
        {
            // Create a copy of the collection passed in
            collection = FdoIDisposableCollection::Create();
            for (int i=0; i < properties->GetCount(); i++)
            {
                item = properties->GetItem(i);
                collection->Add(item);
                FDO_SAFE_RELEASE(item);
            }

            SetBaseCollection(collection);
            FDO_SAFE_RELEASE(collection);
        }
        catch (FdoException* pExcept)
        {
            FDO_SAFE_RELEASE(item);
            FDO_SAFE_RELEASE(collection);
            throw pExcept;
        }
    }
    else
        SetBaseCollection(NULL);
}
// Converts the filter expression to it's well defined text representation.
FdoString* FdoComparisonCondition::ToStringInternal( FdoIdentifierCollection *pIdCol )
{
    FdoStringUtility::ClearString(m_toString);

    FdoExpression*  pRight = GetRightExpression();
    FdoExpression*  pLeft = GetLeftExpression();
    if (pRight == NULL || pLeft == NULL)
    {
        FDO_SAFE_RELEASE(pRight);
        FDO_SAFE_RELEASE(pLeft);
        FdoFilterException* pExcept = FdoFilterException::Create(FdoException::NLSGetMessage(FDO_NLSID(FILTER_2_INCOMPLETECOMPARISONCONDITION)));
        throw pExcept;
    }

    const wchar_t*    szOp;
    switch (GetOperation())
    {
    default:
    case FdoComparisonOperations_EqualTo:
        szOp = L" = ";
        break;
    case FdoComparisonOperations_NotEqualTo:
        szOp = L" <> ";
        break;
    case FdoComparisonOperations_GreaterThan:
        szOp = L" > ";
        break;
    case FdoComparisonOperations_GreaterThanOrEqualTo:
        szOp = L" >= ";
        break;
    case FdoComparisonOperations_LessThan:
        szOp = L" < ";
        break;
    case FdoComparisonOperations_LessThanOrEqualTo:
        szOp = L" <= ";
        break;
    case FdoComparisonOperations_Like:
        szOp = L" LIKE ";
        break;
    }

    try
    {
        m_toString = FdoStringUtility::MakeString(pLeft->ToStringInternal( pIdCol ), szOp, pRight->ToStringInternal( pIdCol ));
    }
    catch (FdoException* pExcept)
    {
        FDO_SAFE_RELEASE(pRight);
        FDO_SAFE_RELEASE(pLeft);
        throw pExcept;
    }

    pLeft->Release();
    pRight->Release();
    return m_toString;
}
MgServerGetFeatureProviders::~MgServerGetFeatureProviders()
{
    FDO_SAFE_RELEASE(m_providerReg);
    FDO_SAFE_RELEASE(m_connManager);

    // do not release this one
    m_fdoProviderCol = NULL;

    delete m_xmlUtil;
}
// Executes the select command and returns a reference to an IFeatureReader.
// During execution an attempt is made to place a lock on each feature. If
// there are conflicts the conflicts are reported and made available to the
// user via a lock conflict reader. The user retrieves the lock conflict
// reader when executing the function "GetLockConflicts()".
// NOTE: The current implementation is a work-around due some timing issues as
//       explained: When using DBI to apply a lock on an object the lock is
//       actually applied only when the object is fetched via the procedure
//       dbi_fetch. In this command the fetching of the object is delayed until
//       the user actually queries the feature reader. That means that locks
//       are applied at that time. As a result the feature reader should have a
//       method to retrieve the lock conflicts because this object documents
//       them. This is not the case. Therefore, until a better solution is found
//       the work-around is to have two passes for the execution of the command:
//       the first one actually locks the objects and provides lock conflict
//       information whereas the second pass prepares the feature reader for the
//       user to retrieve the requested data.
FdoIFeatureReader* FdoRdbmsSelectCommand::ExecuteWithLock()
{

    FdoFilter       *tempFilter     = NULL;
    FdoIdentifier   *tempClassName  = NULL;
    FdoIAcquireLock *acquireLockCmd = NULL;

    // If a lock conflict reader already exists dispose it.

    FDO_SAFE_RELEASE(mLockConflictReader);

    // Create the command to lock the objects, set the command parameters
    // and execute it.

    acquireLockCmd = (FdoIAcquireLock *) mConn->CreateCommand(
                                                    FdoCommandType_AcquireLock);

    tempClassName = GetFeatureClassName();
    acquireLockCmd->SetFeatureClassName(tempClassName);
    tempClassName->Release();
    tempFilter = GetFilter();
    acquireLockCmd->SetFilter(tempFilter);
    acquireLockCmd->SetLockStrategy(mLockStrategy);
    acquireLockCmd->SetLockType(mLockType);

    mLockConflictReader = (FdoRdbmsLockConflictReader *)acquireLockCmd->Execute();

    acquireLockCmd->Release();
    acquireLockCmd = NULL;

    // Get the data as requested by the user.

    return (Execute());
}
FdoRfpSpatialContextCollection::~FdoRfpSpatialContextCollection()
{
	FdoInt32 count = GetCount();
	for (FdoInt32 i = count - 1; i >= 0; i--)
	{
		FdoRfpSpatialContext* sc = GetItem(0);
		RemoveAt(0);
		FDO_SAFE_RELEASE(sc);
	}
}
void FdoPropertyDefinitionCollection::Remove(const FdoSchemaElement* value)
{
    FdoSchemaElement*   parent = ((FdoSchemaElement*)value)->GetParent();

    try
    {
        FdoSchemaCollection<FdoPropertyDefinition>::Remove((const FdoPropertyDefinition*)value);
        if (parent)
        {
            if (!(m_changeInfoState & CHANGEINFO_PROCESSING)) // don't notify during Accept/RejectChanges()
                parent->PropertyRemoved((const FdoPropertyDefinition*)value);
            FDO_SAFE_RELEASE(parent);
        }
    }
    catch (FdoException* pExcept)
    {
        FDO_SAFE_RELEASE(parent);
        throw pExcept;
    }
}
///<summary>Sets the name of the schema to destroy as a string.</summary>
/// <param name="value">Input the name of the schema to destroy</param> 
/// <returns>Returns nothing</returns> 
void ArcSDEDestroySchemaCommand::SetSchemaName (FdoString* value)
{
    FDO_SAFE_RELEASE(mSchemaName);
    mSchemaName = NULL;
    if (value != NULL)
    {
        FdoPtr<FdoIdentifier> name = FdoIdentifier::Create (value);
        mSchemaName = name;
        FDO_SAFE_ADDREF(mSchemaName);
    }
}
FdoRdbmsSelectCommand::~FdoRdbmsSelectCommand()
{
    FDO_SAFE_RELEASE(mLockConflictReader);
    FDO_SAFE_RELEASE(mIdentifiers);
    FDO_SAFE_RELEASE(mGroupingFilter);
    FDO_SAFE_RELEASE(mGroupingCol);
    FDO_SAFE_RELEASE(mOrderingIdentifiers);
    FDO_SAFE_RELEASE(mAliasName);
    FDO_SAFE_RELEASE(mJoinCriteria);
    delete mBindParamsHelper;
}
void MgServerFeatureTransactionPool::RemoveExpiredTransaction()
{
    ACE_MT(ACE_GUARD(ACE_Recursive_Thread_Mutex, ace_mon, sm_mutex));

    MG_CONFIGURATION_TRY()

    ACE_Time_Value now = ACE_OS::gettimeofday();
    FeatureTransactionCollection::iterator iterator = m_featureTransactions.begin();
    while (iterator != m_featureTransactions.end())
    {
        MgServerFeatureTransaction* featTransaction = iterator->second;
        if (NULL != featTransaction)
        {
            INT64 time = now.sec() - featTransaction->LastUsed().sec();
            if (time > m_transactionTimeout)
            {
                try
                {
                    // Set timeout for this transaction object. It will release the internal FdoITransaction object.
                    featTransaction->SetTimeout();
                }
                catch (FdoException* e)
                {
                    FDO_SAFE_RELEASE(e);
                }
                catch (...)
                {
                }

                featTransaction->Release();

                // Add the id to timeout list
                m_transactionTimeoutIds.push_back(iterator->first);

                m_featureTransactions.erase(iterator++);
            }
            else
            {
                ++iterator;
            }
        }
        else
        {
            assert(false);
            ++iterator;
        }
    }

    MG_CONFIGURATION_CATCH_AND_THROW(L"MgServerFeatureTransactionPool.RemoveExpiredTransaction")
}
void FdoImportExportTest::Test1 ()
{
    try {
        FdoIoStreamP configStream = FdoIoMemoryStream::Create();
        FdoIoStreamP streamA = FdoIoMemoryStream::Create();
        FdoIoStreamP streamB = FdoIoMemoryStream::Create();

        // Create the configuration document
        CreateConfig1( configStream );

        // Test doing an add-only read from the document. This will fail since the 
        // document contains spatial context Default, which is already in the DataStore/
        printf( "Test1 (Add only, include default) Should fail importing Default ... \n" );

        FdoXmlSpatialContextFlagsP flags = 
            FdoXmlSpatialContextFlags::Create(
                L"www.failure.com",
                FdoXmlFlags::ErrorLevel_High,
                true,
                FdoXmlSpatialContextFlags::ConflictOption_Add,
                true
            );

        FdoBoolean succeeded = false;
	    try {
            DoTest( configStream, streamA, streamB, flags, DB_NAME_SRC_SUFFIX );
		    succeeded = true;
	    }
	    catch ( FdoException* e )
	    {
		    UnitTestUtil::PrintException(e, UnitTestUtil::GetOutputFileName( L"impexp_err1.txt" ), true);
		    FDO_SAFE_RELEASE(e);
	    }

	    CPPUNIT_ASSERT( !succeeded );

#ifdef _WIN32
		UnitTestUtil::CheckOutput( "impexp_err1_master.txt", UnitTestUtil::GetOutputFileName( L"impexp_err1.txt" ) );
#endif

    }
	catch ( FdoException* e ) 
	{
		UnitTestUtil::FailOnException( e );
	}
		
	printf( "Done\n" );

}
FdoSignatureDefinitionCollection *FdoSignatureDefinitionCollection::Create(FdoSignatureDefinition **arguments, FdoInt32 length)
{
    FdoSignatureDefinitionCollection *pColl = new FdoSignatureDefinitionCollection();

    try
    {
        for (FdoInt32 i = 0; i < length; i++)
            pColl->Add(arguments[i]);
    }
    catch (FdoException* pExcept)
    {
        FDO_SAFE_RELEASE(pColl);
        throw pExcept;
    }

    return pColl;
}
// Sets the argument value list of the argument
void FdoArgumentDefinition::SetArgumentValueList (FdoPropertyValueConstraintList *argumentValueList)
{
    FDO_SAFE_RELEASE(m_argumentValueList);
    m_argumentValueList = NULL;

    if (argumentValueList == NULL)
        return;

    m_argumentValueList = FdoPropertyValueConstraintList::Create();

    FdoPtr<FdoDataValueCollection> dest_values = m_argumentValueList->GetConstraintList();
    FdoPtr<FdoDataValueCollection> src_values = argumentValueList->GetConstraintList();
    FdoInt32 count = src_values->GetCount();
    for (FdoInt32 i = 0; i < count; i++)
    {
        FdoPtr<FdoDataValue> data_value = src_values->GetItem(i);
        dest_values->Add(data_value);
    }
}
Beispiel #14
0
FdoFgfCurveString::FdoFgfCurveString(
    FdoFgfGeometryFactory * factory,
    FdoFgfGeometryPools * pools,
    FdoCurveSegmentCollection* curveSegs
    )
    : FdoFgfGeometryImpl<FdoICurveString>(factory, pools)
{
	if ( (NULL == curveSegs) ||
          (0 == curveSegs->GetCount()) )
		 throw FdoException::Create(FdoException::NLSGetMessage(FDO_NLSID(FDO_1_INVALID_INPUT_ON_CLASS_CREATION),
                                                                L"FdoFgfCurveString",
                                                                L"curveSegs/factory"));

    FdoByteArray * newByteArray = FgfUtil::GetPoolsNoRef(m_pools)->GetByteArray();

	// Geometrytype
	FGFUTIL_WRITE_INT32(&newByteArray, FdoGeometryType_CurveString);

	// Coordtype - from 1st element in curveSegs array
    FdoPtr<FdoICurveSegmentAbstract> firstCurve = curveSegs->GetItem(0);
	FdoInt32 dimensionality = firstCurve->GetDimensionality();
	FGFUTIL_WRITE_INT32(&newByteArray, dimensionality);

	// Startpoint - from 1st element in curveSegs array
	FdoPtr<FdoIDirectPosition> startPos = firstCurve->GetStartPosition();
	FgfUtil::WriteDirectPosition(&newByteArray, startPos);

	// Number of curveSegs
	FGFUTIL_WRITE_INT32(&newByteArray, curveSegs->GetCount());

	// CurveSegs
	for (FdoInt32 i=0; i<curveSegs->GetCount(); i++)
	{
        FdoPtr<FdoICurveSegmentAbstract> curveSeg = curveSegs->GetItem(i);
		FgfUtil::WriteCurveSegment(curveSeg, &newByteArray);
	} 

    SetFgf(newByteArray, NULL, 0);
    FDO_SAFE_RELEASE(newByteArray);
}
Beispiel #15
0
FdoIGeometry * FgfUtil::ReadGeometry(FdoFgfGeometryFactory * factory, FdoGeometryType expectedGeometryType, const FdoByte ** inputStream, const FdoByte * streamEnd)
{
    FdoPtr<FdoIGeometry> geometry;
    
    const FdoByte * streamStartOfGeometry = *inputStream;
    FgfUtil::SkipGeometry(inputStream, streamEnd);
    const FdoByte * streamEndOfGeometry = *inputStream;
    FdoInt32 streamSizeOfGeometry = (FdoInt32)(streamEndOfGeometry - streamStartOfGeometry);

    // Copy the FGF data to a new (possibly pooled) byte array.
    // Don't use "FdoPtr" smart pointer while the array is being updated.
    FdoByteArray * newByteArray = factory->GetByteArray();
	newByteArray = FdoByteArray::Append(newByteArray, streamSizeOfGeometry, (FdoByte *)streamStartOfGeometry);

    // Create a new (possibly pooled) geometry from the byte array.
    geometry = factory->CreateGeometryFromFgf(newByteArray);

    if (FdoGeometryType_None != expectedGeometryType &&
        expectedGeometryType != geometry->GetDerivedType())
    	throw FdoException::Create(FdoException::NLSGetMessage(FDO_NLSID(FDO_7_INVALIDFGF)));

    FDO_SAFE_RELEASE(newByteArray);
    return FDO_SAFE_ADDREF(geometry.p);
}
// Sets the value to bind to the parameter as a LiteralValue.
void FdoParameterValue::SetValue(FdoLiteralValue* value)
{
	FDO_SAFE_RELEASE(m_value);
	m_value = FDO_SAFE_ADDREF(value);
}
ExpressionFunctionLayerId::~ExpressionFunctionLayerId()
{
    FDO_SAFE_RELEASE(m_layerIdValue);
    FDO_SAFE_RELEASE(m_functionDefinition);
}
// Gets the value to bind to the parameter as a String.
void FdoParameterValue::SetValue(FdoString* value)
{
	FDO_SAFE_RELEASE(m_value);
	m_value = FdoStringValue::Create(value);
}
FdoParameterValue::~FdoParameterValue()
{
    FdoStringUtility::ClearString(m_name);
    FDO_SAFE_RELEASE(m_value);
}
FdoArgumentDefinition::~FdoArgumentDefinition ()
{
	FdoStringUtility::ClearString(m_name);
	FdoStringUtility::ClearString(m_description);
    FDO_SAFE_RELEASE(m_argumentValueList);
}
Beispiel #21
0
MgdSqlDataReader::~MgdSqlDataReader() 
{
	FDO_SAFE_RELEASE(m_reader);
    m_connection = NULL;
} 
FdoXmlSpatialContextReader::~FdoXmlSpatialContextReader()
{
    FDO_SAFE_RELEASE(mSCHandler);
}
ExpressionFunctionMapCenterX::~ExpressionFunctionMapCenterX()
{
    FDO_SAFE_RELEASE(m_xValue);
    FDO_SAFE_RELEASE(m_functionDefinition);
}
// Sets the Expression that defines the right side of the comparison.
void FdoComparisonCondition::SetRightExpression(FdoExpression* value)
{
    FDO_SAFE_RELEASE(m_rightExpression);
	m_rightExpression = FDO_SAFE_ADDREF(value);
}
ExpressionFunctionArgb::~ExpressionFunctionArgb()
{
    FDO_SAFE_RELEASE(m_argbValue);
    FDO_SAFE_RELEASE(m_functionDefinition);
}
ExpressionFunctionMapName::~ExpressionFunctionMapName()
{
    FDO_SAFE_RELEASE(m_mapNameValue);
    FDO_SAFE_RELEASE(m_functionDefinition);
}
FdoComparisonCondition::~FdoComparisonCondition()
{
    FDO_SAFE_RELEASE(m_leftExpression);
    FDO_SAFE_RELEASE(m_rightExpression);
}
Beispiel #28
0
FdoException::~FdoException()
{
    FdoStringUtility::ClearString(m_message);
    FDO_SAFE_RELEASE(m_cause);
}
Beispiel #29
0
ExpressionFunctionLookup::~ExpressionFunctionLookup()
{
    FDO_SAFE_RELEASE(m_functionDefinition);
}
Beispiel #30
0
void FdoException::SetCause(FdoException* cause)
{
    FDO_SAFE_ADDREF(cause);
    FDO_SAFE_RELEASE(m_cause);
    m_cause = cause;
}