/////////////////////////////////////////////////////////////////////////////
//	CAggregate::QueryInterface
//
/////////////////////////////////////////////////////////////////////////////
HRESULT CAggregate::QueryInterface(REFIID riid, LPVOID *ppv)
{
	HRESULT hr = S_OK;
	
	//TEST_ NULL
	if(ppv == NULL)
		return E_INVALIDARG;
	*ppv = NULL;

	//Support IID_IUnknown
	if(riid == IID_IUnknown)
	{
		*ppv = (IUnknown*)this;
		SAFE_ADDREF((IUnknown*)*ppv);
	}
	else if(riid == IID_IAggregate)
	{
		*ppv = (IUnknown*)this;
		SAFE_ADDREF((IUnknown*)*ppv);
	}
	else if(m_spUnkInner)
	{
		//Delegate the the Inner Object
		//This is not "circular" since this interface is the IID_IUnknown
		//interface only, which has its own non-delegating QI...
		hr = m_spUnkInner->QueryInterface(riid, ppv);
	}
	else
	{
		return E_NOINTERFACE;
	}

	return hr;
}
Beispiel #2
0
MgdCreateFileFeatureSource::MgdCreateFileFeatureSource(
    MgResourceIdentifier* resource,
    MgFileFeatureSourceParams* params)
{
    m_resource = resource;
    SAFE_ADDREF(resource);

    m_params = params;
    SAFE_ADDREF(params);
}
Beispiel #3
0
//////////////////////////////////////////////////////////////
// Create and initialize an MgdMapPlot instance.
MgdMapPlot::MgdMapPlot(MgdMap* map, MgdPlotSpecification* plotSpec, MgdLayout* layout)
{
    if (NULL == map || NULL == plotSpec)
    {
        throw new MgNullArgumentException(L"MgdMapPlot.MgdMapPlot", __LINE__, __WFILE__, NULL, L"", NULL);
    }

    Initialize();

    m_map = SAFE_ADDREF(map);
    m_plotSpec = SAFE_ADDREF(plotSpec);
    m_layout = SAFE_ADDREF(layout);

    m_plotInstruction = MgdMapPlotInstruction::UseMapCenterAndScale;
}
////////////////////////////////////////////////////////
// CBase::CBase
//
////////////////////////////////////////////////////////
CBase::CBase(CBase* pCBase,	LPUNKNOWN pUnkOuter)
{
	m_cRef		= 0;												
	m_pCBase	= pCBase;
	SAFE_ADDREF(m_pCBase);
	
	m_pUnkOuter = pUnkOuter ? pUnkOuter : this;

	//AddRef the parent object...
	//This is done since all Child objects in OLE DB have some way to 
	//get back to the parent, Session -> DataSource, Rowset -> Command.
	//We need to addref the parent so its still active whenever needed to get back to
	if(m_pCBase)
		SAFE_ADDREF(m_pCBase->m_pUnkOuter);
}
Beispiel #5
0
//////////////////////////////////////////////////////////////
// Set the extent and expand to fit flag.
void MgdMapPlot::SetExtent(MgEnvelope* extent, bool expandToFit)
{
    SAFE_RELEASE(m_extent);
    m_extent = SAFE_ADDREF(extent);
    m_bExpandToFit = expandToFit;
    m_plotInstruction = MgdMapPlotInstruction::UseOverriddenExtent;
}
Beispiel #6
0
MgdFeatureInfoRenderer::MgdFeatureInfoRenderer(MgdSelection* selection, int maxFeatures, double mapScale, double* point, SE_Renderer* impRenderer)
: m_extents(0.0, 0.0, 1.0, 1.0),
  m_numFeatures(0),
  m_url(L""),
  m_tooltip(L""),
  m_props(NULL),
  m_layerId(L""),
  m_nMaxFeatures(maxFeatures),
  m_mapScale(mapScale),
  m_fcName(L""),
  m_mapInfo(NULL),
  m_layerInfo(NULL),
  m_fcInfo(NULL),
  m_pointTest(false),
  m_impRenderer(impRenderer)
{
    m_selection = SAFE_ADDREF(selection);
    m_keyEncode = new KeyEncode();
    if(point != NULL)
    {
        m_point[0] = point[0];
        m_point[1] = point[1];
        m_needPointTest = true;
    }
    else
        m_needPointTest = false;
}
cParticleSystem::cParticleSystem(LPD3DXSPRITE pSprite)
: m_fLifespan(0.0f)
, m_fLifespanVar(0.0f)
, m_fStartSize(0.0f)
, m_fStartSizeVar(0.0f)
, m_fFinishSize(0.0f)
, m_fFinishSizeVar(0.0f)
, m_fEmitterAngle(0.0f)
, m_fEmitterAngleVar(0.0f)
, m_fStartRot(0.0f)
, m_fStartRotVar(0.0f)
, m_fEndRot(0.0f)
, m_fEndRotVar(0.0f)
, m_fXVar(0.0f)
, m_fYVar(0.0f)
, m_fSpeed(0.0f)
, m_fSpeedVar(0.0f)
, m_fGravityX(0.0f)
, m_fGravityY(0.0f)
, m_fTanAcc(0.0f)
, m_fTanAccVar(0.0f)
, m_fRadAcc(0.0f)
, m_fRadAccVar(0.0f)
, m_dwStartColor(0)
, m_dwStartColorVar(0)
, m_dwFinishColor(0)
, m_dwFinishColorVar(0)
{
	SAFE_ADDREF(pSprite);
	m_pSprite = pSprite;
}
MgByteReader* MgResourceDefinitionManager::GetRepository(
    MgResourceIdentifier* resource)
{
    assert(NULL != resource && resource->IsRoot());
    Ptr<MgByteReader> byteReader;

    MG_RESOURCE_SERVICE_TRY()

    // Get the resource.

    XmlDocument xmlDoc = GetDocument(*resource);

    // Create a byte reader.

    string document;
    xmlDoc.getContent(document); // TODO: Improve performance by using getContentAsXmlInputStream?

    Ptr<MgByteSource> byteSource = new MgByteSource(
        (unsigned char*)document.c_str(), (INT32)document.length());

    byteSource->SetMimeType(MgMimeType::Xml);
    byteReader = byteSource->GetReader();

    MG_RESOURCE_CONTAINER_CATCH_AND_THROW(L"MgResourceDefinitionManager.GetRepository")

    return SAFE_ADDREF((MgByteReader*)byteReader);
}
Beispiel #9
0
//////////////////////////////////////////////////////////////////
///<summary>
/// Construct a MgProxyFeatureReader object from a byte source
///</summary>
///<param name="byteSource">Byte  source object</param>
///
MgProxyFeatureReader::MgProxyFeatureReader(MgFeatureSet* featureSet)
{
    m_currRecord = 0;
    m_serverfeatReader = L"";
    m_set = SAFE_ADDREF(featureSet);
    m_service = NULL;
}
// ----------------------------------------------------------------------------
// Function:
//      CSwapPropPage::AddPages
//
// Description:
//      Implementation of IShellPropSheetExt::AddPages. Adds one or more pages
//      to a property sheet that the Shell displays for a file object.
//
// Parameters:
//      lpfnAddPage - [in] Address of a function that the property sheet
//                    handler calls to add a page to the property sheet. The
//                    function takes a property sheet handle returned by the
//                    CreatePropertySheetPage function and the lParam parameter
//                    passed to the AddPages method. 
//      lParam - [in] Parameter to pass to the function specified by the
//               lpfnAddPage method.
//
// Return values:
//      Returns S_OK if successful. If the method fails, an OLE-defined error
//      code is returned
// ----------------------------------------------------------------------------
_Use_decl_annotations_
HRESULT STDMETHODCALLTYPE CSwapPropPage::AddPages
(
    LPFNADDPROPSHEETPAGE    lpfnAddPage,    // See PrSht.h
    LPARAM                  lParam          // Used by caller, don't modify
)
{
    HRESULT                 hr = S_OK;
    PROPSHEETPAGE           psp;
    HPROPSHEETPAGE          hPage1 = NULL;
    AudioFXExtensionParams* pAudioFXParams = (AudioFXExtensionParams*)lParam;
#pragma warning(push)
#pragma warning(disable: 28197)
    AudioFXExtensionParams* pAudioFXParamsCopy = new AudioFXExtensionParams;
#pragma warning(pop)

    if (pAudioFXParamsCopy == NULL)
    {
        return E_OUTOFMEMORY;
    }

    // Make a copy of the params
    CopyMemory(pAudioFXParamsCopy, pAudioFXParams, sizeof(AudioFXExtensionParams));
    SAFE_ADDREF(pAudioFXParamsCopy->pFxProperties);

    // Initialize property page params and create page
    psp.dwSize        = sizeof(psp);
    psp.dwFlags       = PSP_USEREFPARENT | PSP_USECALLBACK;
    psp.hInstance     = _AtlBaseModule.GetModuleInstance();
    psp.hIcon         = 0;
    psp.pcRefParent   = (UINT*)&m_dwRef;
    psp.lParam        = (LPARAM)pAudioFXParamsCopy;
    psp.pszTemplate   = MAKEINTRESOURCE(IDD_SWAP_PROP_PAGE);
    psp.pfnDlgProc    = (DLGPROC)DialogProcPage1;
    psp.pfnCallback   = PropSheetPageProc;

    // Create the property sheet page and add the page
    hPage1 = CreatePropertySheetPage(&psp);
    if (hPage1)
    {
        if (!lpfnAddPage(hPage1, pAudioFXParams->AddPageParam))
        {
            hr = E_FAIL;
            delete pAudioFXParamsCopy;
            DestroyPropertySheetPage(hPage1);
        }
        else
        {
            // Add ref for page
            this->AddRef();
        }
    }
    else
    {
        delete pAudioFXParamsCopy;
        hr = E_OUTOFMEMORY;
    }

    return(hr);
}
Beispiel #11
0
//////////////////////////////////////////////////////////////////
/// <summary>
/// Gets the DTime value of the specified property. No conversion is
/// performed, thus the property must be a of date type or the result
/// is NULL</summary>
/// <param name="index">Property index.</param>
/// <returns>Returns the DTime value.</returns>
/// EXCEPTIONS:
/// InvalidPropertyType
MgDateTime* MgProxyFeatureReader::GetDateTime(INT32 index)
{
    Ptr<MgDateTimeProperty> ptrProp = (MgDateTimeProperty*)GetProperty(index, MgPropertyType::DateTime);
    Ptr<MgDateTime> retVal = ptrProp->GetValue();

    return SAFE_ADDREF((MgDateTime*)retVal);
}
Beispiel #12
0
//////////////////////////////////////////////////////////////////
/// <summary>
/// Gets the DTime value of the specified property. No conversion is
/// performed, thus the property must be a of date type or the result
/// is NULL</summary>
/// <param name="propertyName">Property name.</param>
/// <returns>Returns the DTime value.</returns>
/// EXCEPTIONS:
/// InvalidPropertyType
MgDateTime* MgProxyFeatureReader::GetDateTime(CREFSTRING propertyName)
{
    Ptr<MgDateTimeProperty> ptrProp = (MgDateTimeProperty*)GetProperty(propertyName, MgPropertyType::DateTime);
    Ptr<MgDateTime> retVal = ptrProp->GetValue();

    return SAFE_ADDREF((MgDateTime*)retVal);
}
Beispiel #13
0
/// <summary>
/// Constructor
/// </summary>
/// <param name="className">
/// Name of class from which data to be deleted
/// </param>
/// <param name="filterText">
/// Filter crieteria to be applied for deletion
/// </param>
/// <returns>
/// Nothing
/// </returns>
MgInsertFeatures::MgInsertFeatures(CREFSTRING className, MgBatchPropertyCollection* propertyValues)
{
    if (className.empty())
    {
        MgStringCollection arguments;
        arguments.Add(L"1");
        arguments.Add(MgResources::BlankArgument);

        throw new MgInvalidArgumentException(L"MgInsertFeatures.MgInsertFeatures",
            __LINE__, __WFILE__, &arguments, L"MgStringEmpty", NULL);
    }

    if (propertyValues == NULL)
    {
        throw new MgNullArgumentException(L"MgInsertFeatures.MgInsertFeatures", __LINE__, __WFILE__, NULL, L"", NULL);
    }

    if (propertyValues->GetCount() == 0)
    {
        MgStringCollection arguments;
        arguments.Add(L"2");
        arguments.Add(L"0");

        throw new MgInvalidArgumentException(L"MgInsertFeatures.MgInsertFeatures",
            __LINE__, __WFILE__, &arguments, L"MgPropertyValuesEmpty", NULL);
    }

    m_className = className;
    m_properties = SAFE_ADDREF(propertyValues);
}
Beispiel #14
0
//////////////////////////////////////////////////////////////
// Set the view center and scale.
void MgdMapPlot::SetCenterAndScale(MgCoordinate* center, double scale)
{
    SAFE_RELEASE(m_center);
    m_center = SAFE_ADDREF(center);
    m_scale = scale;
    m_plotInstruction = MgdMapPlotInstruction::UseOverriddenCenterAndScale;
}
Beispiel #15
0
cSprite::cSprite(LPD3DXSPRITE pSprite)
: m_pSprite(NULL)
, m_pTexture(NULL)
{
	SAFE_ADDREF(pSprite);
	m_pSprite = pSprite;
	m_dwColor = D3DCOLOR_ARGB(255, 255, 255, 255);
}
Beispiel #16
0
// ----------------------------------------------------------------------------------------------
Texture::Texture(Texture* tex)
{           
    if(tex)
    {
        m_tex = tex->m_tex;
        m_view = tex->m_view;
        m_texType = tex->GetTextureType();
        SAFE_ADDREF(m_tex);
        SAFE_ADDREF(m_view);
    }
    else
    {
        m_tex = NULL;
        m_view = NULL;
        m_texType = TextureType::Unknown;
    }
}
Beispiel #17
0
MgdSqlDataReader::MgdSqlDataReader(MgdFeatureConnection* conn, FdoISQLDataReader* reader)
{
	m_reader = FDO_SAFE_ADDREF(reader);
    m_connection = SAFE_ADDREF(conn);

    // The reader takes ownership of the FDO connection
    m_connection->OwnReader();
}
Beispiel #18
0
void MgProxySqlDataReader::SetService(MgFeatureService* service)
{
    CHECKNULL(service, L"MgProxySqlDataReader.SetService");

    if (m_service == NULL)
    {
        m_service = SAFE_ADDREF(service);
    }
}
Beispiel #19
0
int MgdUpdateFeaturesCommand::ExecuteUpdate(MgResourceIdentifier* resource, CREFSTRING className, MgPropertyCollection* propertyValues, CREFSTRING filter, MgTransaction* trans)
{
    int updated = 0;

    MG_FEATURE_SERVICE_TRY()

    CHECK_FEATURE_SOURCE_ARGUMENT(resource, L"MgdUpdateFeaturesCommand::ExecuteUpdate");
	CHECKARGUMENTNULL(propertyValues, L"MgdUpdateFeaturesCommand::ExecuteUpdate");
	if (className.empty())
		throw new MgNullArgumentException(L"MgdUpdateFeaturesCommand::ExecuteUpdate", __LINE__, __WFILE__, NULL, L"", NULL);

    Ptr<MgdFeatureConnection> connWrap;
	FdoPtr<FdoIConnection> conn;
    FdoPtr<FdoITransaction> fdoTrans;
    Ptr<MgdTransaction> mgTrans = dynamic_cast<MgdTransaction*>(trans);
    if (NULL != mgTrans)
    {
        SAFE_ADDREF(mgTrans.p);
        Ptr<MgResourceIdentifier> origFeatureSource = mgTrans->GetFeatureSource();
        //Check that the transaction originates from the same feature source
        if (origFeatureSource->ToString() != resource->ToString())
            throw new MgInvalidArgumentException(L"MgdUpdateFeaturesCommand::ExecuteUpdate", __LINE__, __WFILE__, NULL, L"", NULL);

        connWrap = mgTrans->GetConnection(); //Connection is already open
        fdoTrans = mgTrans->GetFdoTransaction();
    }
    else
    {
        connWrap = new MgdFeatureConnection(resource);
    }

    conn = connWrap->GetConnection();
	FdoPtr<FdoIUpdate> update = (FdoIUpdate*)conn->CreateCommand(FdoCommandType_Update);
	update->SetFeatureClassName(className.c_str());
	
	if (!filter.empty())
		update->SetFilter(filter.c_str());

    if (NULL != fdoTrans.p)
        update->SetTransaction(fdoTrans);

	FdoPtr<FdoPropertyValueCollection> propVals = update->GetPropertyValues();
	for (INT32 i = 0; i < propertyValues->GetCount(); i++)
	{
		Ptr<MgProperty> mgp = propertyValues->GetItem(i);
		FdoPtr<FdoPropertyValue> pv = MgdFeatureUtil::MgPropertyToFdoProperty(mgp);

		propVals->Add(pv);
	}

	updated = update->Execute();

    MG_FEATURE_SERVICE_CATCH_AND_THROW_WITH_FEATURE_SOURCE(L"MgdUpdateFeaturesCommand::ExecuteUpdate", resource)

    return updated;
}
Beispiel #20
0
void MgProxyFeatureReader::SetService(MgFeatureService* service)
{
    CHECKNULL(service, L"MgProxyFeatureReader.SetService");

    if (m_service == NULL)
    {
        m_service = SAFE_ADDREF(service);
        SetServiceForFeatureProperties(service);
    }
}
Beispiel #21
0
//////////////////////////////////////////////////////////////
// Initialize class members which may not be set by the constructors
void MgdMapPlot::Initialize()
{
    Ptr<MgCoordinate> initCoord = new MgCoordinateXY(0, 0);
    m_center = initCoord;
    SAFE_ADDREF(m_center);
    m_scale = 0;
    m_extent = new MgEnvelope(initCoord, initCoord);
    m_bExpandToFit = true;
    m_layout = NULL;
}
Beispiel #22
0
MgdMapPlot::MgdMapPlot(MgdMap* map, MgEnvelope* extent, bool expandToFit,
                     MgdPlotSpecification* plotSpec, MgdLayout* layout)
{
    if (map == NULL || extent == NULL || plotSpec == NULL)
    {
        throw new MgNullArgumentException(L"MgdMapPlot.MgdMapPlot", __LINE__, __WFILE__, NULL, L"", NULL);
    }

    Initialize();

    m_map = SAFE_ADDREF(map);
    SAFE_RELEASE(m_extent);
    m_extent = SAFE_ADDREF(extent);
    m_bExpandToFit = expandToFit;
    m_plotSpec = SAFE_ADDREF(plotSpec);
    m_layout = SAFE_ADDREF(layout);

    m_plotInstruction = MgdMapPlotInstruction::UseOverriddenExtent;
}
Beispiel #23
0
MgdMapPlot::MgdMapPlot(MgdMap* map, MgCoordinate* center, double scale,
                     MgdPlotSpecification* plotSpec, MgdLayout* layout)
{
    if (NULL == map || NULL == center || NULL == plotSpec)
    {
        throw new MgNullArgumentException(L"MgdMapPlot.MgdMapPlot", __LINE__, __WFILE__, NULL, L"", NULL);
    }

    Initialize();

    m_map = SAFE_ADDREF(map);
    SAFE_RELEASE(m_center);
    m_center = SAFE_ADDREF(center);
    m_scale = scale;
    m_plotSpec = SAFE_ADDREF(plotSpec);
    m_layout = SAFE_ADDREF(layout);

    m_plotInstruction = MgdMapPlotInstruction::UseOverriddenCenterAndScale;
}
Beispiel #24
0
///////////////////////////////////////////////////////////////////////////
//  <summary>
//  Constructs a MgStreamData object with the given parameters/
//  </summary>
//
//  <param name = "pHandler">
//  The ClientHandler object that is handling this stream.
//  </param>
//
//  <param name = "handle">
//  The ACE_HANDLE underlying the stream.
//  </param>
//
//  <param name = "pStreamHelper">
//  The MgStreamHelper object that handles data I/O for this stream.
//  </param>
MgStreamData::MgStreamData( ACE_HANDLE handle, MgStreamHelper* pStreamHelper ) :
    m_Handle( handle ),
    m_pStreamHelper( SAFE_ADDREF(pStreamHelper) ),
    m_Version( 0 ),
    m_DataSize( 0 ),
    m_DataRead( 0 ),
    m_bError( false )
{
    ACE_ASSERT( handle != 0 );
    ACE_ASSERT( pStreamHelper != NULL );
};
///////////////////////////////////////////////////////////////////////////////
/// \brief
/// Return an existing MgFeatureSchemaCacheItem.
///
MgFeatureSchemaCacheItem* MgFeatureServiceCacheEntry::GetFeatureSchemaCacheItem(CREFSTRING schemaName)
{
    Ptr<MgFeatureSchemaCacheItem> item;
    MgFeatureSchemaCacheItems::iterator i =
        m_featureSchemaCacheItems.find(schemaName);

    if (m_featureSchemaCacheItems.end() != i)
    {
        item = SAFE_ADDREF(i->second);
    }

    return item.Detach();
}
///////////////////////////////////////////////////////////////////////////////
/// \brief
/// Return an existing MgFeatureSchemaCacheItem or a newly created one
/// if it does not exist.
///
MgFeatureSchemaCacheItem* MgFeatureServiceCacheEntry::SetFeatureSchemaCacheItem(CREFSTRING schemaName)
{
    Ptr<MgFeatureSchemaCacheItem> item = GetFeatureSchemaCacheItem(schemaName);

    if (NULL == item.p)
    {
        item = new MgFeatureSchemaCacheItem();
        m_featureSchemaCacheItems.insert(MgFeatureSchemaCacheItems::value_type(
            schemaName, SAFE_ADDREF(item.p)));
    }

    return item.Detach();
}
Beispiel #27
0
HRESULT CSWPosImage::SetImage(CSWImage* pImage)
{
	if (NULL != pImage)
	{
		SAFE_RELEASE(m_pImage);
		m_pImage = pImage;
		SAFE_ADDREF(m_pImage);

		return S_OK;
	}

	return E_INVALIDARG;
}
Beispiel #28
0
// Get the property for the specified index
MgProperty* MgProxyFeatureReader::GetProperty(INT32 index)
{
    CHECKNULL(m_set, L"MgProxyFeatureReader.GetProperty");
    CHECK_FEATURESET_COUNT(m_set, L"MgProxyFeatureReader.GetProperty");

    Ptr<MgPropertyCollection> ptrCol = m_set->GetFeatureAt(m_currRecord-1);
    CHECKNULL(ptrCol, L"MgProxyFeatureReader.GetProperty");

    Ptr<MgProperty> ptrProp = ptrCol->GetItem(index);
    CHECKNULL(ptrProp, L"MgProxyFeatureReader.GetProperty");

    return SAFE_ADDREF(ptrProp.p);
}
MgByteReader* MgResourceDefinitionManager::GetResource(
    MgResourceIdentifier* resource, const MgDataBindingInfo* dataBindingInfo)
{
    assert(NULL != resource);
    Ptr<MgByteReader> byteReader;

    MG_RESOURCE_SERVICE_TRY()

    // Get the resource.

    XmlDocument xmlDoc = GetDocument(*resource);
    string document;

    xmlDoc.getContent(document);

    // Bind the data if required.

    if (NULL != dataBindingInfo)
    {
        // Substitute all the tags if necessary.

        XmlValue tagValue;

        if (xmlDoc.getMetaData(MgResourceInfo::sm_metadataUri,
                MgResourceInfo::sm_metadataNames[MgResourceInfo::Tags],
                tagValue))
        {
            STRING resourceTags;
            MgUtil::MultiByteToWideChar(tagValue.asString(), resourceTags);

            // If there is no resource tag, then just do the substitution for
            // the login username and password.

            MgTagManager tagManager(resourceTags);
            tagManager.SubstituteTags(*dataBindingInfo, document);
        }
    }

    // Create a byte reader.

    Ptr<MgByteSource> byteSource = new MgByteSource(
        (unsigned char*)document.c_str(), (INT32)document.length());

    byteSource->SetMimeType(MgMimeType::Xml);
    byteReader = byteSource->GetReader();

    MG_RESOURCE_CONTAINER_CATCH_AND_THROW(L"MgResourceDefinitionManager.GetResource")

    return SAFE_ADDREF((MgByteReader*)byteReader);
}
void MgFeatureNumericFunctions::Initialize(MgReader* reader, FdoFunction* customFunction, CREFSTRING propertyAlias)
{
    CHECKNULL((MgReader*)reader, L"MgFeatureNumericFunctions.Initialize");
    CHECKNULL((FdoFunction*)customFunction, L"MgFeatureNumericFunctions.Initialize");

    if(1 == reader->GetPropertyCount())
    {
        m_type = MgServerFeatureUtil::GetPropertyDefinition(reader, m_propertyName);
    }
    else
    {
        // Only get the property needed
        FdoPtr<FdoExpressionCollection> exprCol = customFunction->GetArguments();
        FdoInt32 cnt = exprCol->GetCount();
        FdoPtr<FdoExpression> expr;
        if(cnt == 1)
        {
            expr = exprCol->GetItem(0);
            FdoIdentifier* propName = dynamic_cast<FdoIdentifier*>(expr.p);
            CHECKNULL(propName, L"MgFeatureNumericFunctions.Initialize");
            m_propertyName = propName->GetName();
            m_type = reader->GetPropertyType(m_propertyName);
        }
        else
        {
            // Throw original exception
            m_type = MgServerFeatureUtil::GetPropertyDefinition(reader, m_propertyName);
        }
    }

    // TODO: Should we really check this, may be we can ignore ??
    // because we can only come to here if property type is numeric
    this->CheckSupportedPropertyType();

    // We must have an property alias
    // Though we can name a property with same name as function expression
    // But Fdo forces to have an alias. Therefore we implement this restriction.
    if (propertyAlias.empty())
    {
        STRING message = MgServerFeatureUtil::GetMessage(L"MgMissingPropertyAlias");

        MgStringCollection arguments;
        arguments.Add(message);
        throw new MgFeatureServiceException(L"MgFeatureDistribution.Initialize", __LINE__, __WFILE__, &arguments, L"", NULL);
    }

    m_reader = SAFE_ADDREF(reader);
    m_customFunction = FDO_SAFE_ADDREF(customFunction);
    m_propertyAlias = propertyAlias;
}