///////////////////////////////////////////////////////////////////////////
// <summary>
// Processes the appropriate operation using the Operation Packet and
// StreamData objects given during construction.
// Overrides IMgServiceHander::ProcessOperation().
// </summary>
IMgServiceHandler::MgProcessStatus MgServerAdminServiceHandler::ProcessOperation()
{
IMgServiceHandler::MgProcessStatus status = IMgServiceHandler::mpsError;
auto_ptr<IMgOperationHandler> handler;
MG_TRY()
handler.reset(MgServerAdminOperationFactory::GetOperation(
m_packet.m_OperationID, m_packet.m_OperationVersion));
assert(NULL != handler.get());
handler->Initialize(m_data, m_packet);
handler->Execute();
status = IMgServiceHandler::mpsDone;
MG_CATCH(L"MgServerAdminServiceHandler.ProcessOperation")
if (mgException != NULL && NULL != handler.get())
{
status = (handler.get()->HandleException(mgException) ?
IMgServiceHandler::mpsDone : IMgServiceHandler::mpsError);
}
if (IMgServiceHandler::mpsDone != status)
{
MG_THROW();
}
return status;
}
/* converting a CellMatrix of interpolation types to a sid::vector<int> */
vector<int> FromCellMatrixToInterpolVector(const CellMatrix& aCM)
{
if (aCM.Size() > maxInterpoltypesNb)
{
ostringstream vOs;
vOs << "Maximum number of interpolations is " << maxInterpoltypesNb << ", please advise.";
MG_THROW(vOs.str());
}
vector<string> vInterpolTypesStr = FromCellMatrixToVectorStr(aCM);
size_t vSize(vInterpolTypesStr.size());
vector<int> vInterpolTypesInt(vSize);
for(size_t i=0; i<vSize; ++i)
vInterpolTypesInt[i] = InterpolMethodConvertor[vInterpolTypesStr[i]];
return vInterpolTypesInt;
}
///////////////////////////////////////////////////////////////////////////////
/// \brief
/// Handle the Resource Change Notification event.
/// Any tile cache associated with the specified Map Definition resources
/// will be cleared.
///
bool MgdTileService::NotifyResourcesChanged(MgSerializableCollection* resources, bool strict)
{
bool success = true;
if (NULL != resources)
{
INT32 numResources = resources->GetCount();
if (numResources > 0)
{
for (INT32 i = 0; i < numResources; ++i)
{
Ptr<MgSerializable> serializableObj = resources->GetItem(i);
MgResourceIdentifier* resource =
dynamic_cast<MgResourceIdentifier*>(serializableObj.p);
ACE_ASSERT(NULL != resource);
if (NULL != resource && resource->IsResourceTypeOf(MgResourceType::MapDefinition))
{
MG_TRY()
// clear any cached mgmap objects
ClearMapCache(resource->ToString());
// clear any tile cache associated with this map
m_tileCache->Clear(resource);
MG_CATCH(L"MgdTileService.NotifyResourcesChanged")
if (NULL != mgException.p)
{
success = false;
if (strict)
{
MG_THROW();
}
/*
else
{
MgdLogManager* logManager = MgdLogManager::GetInstance();
ACE_ASSERT(NULL != logManager);
logManager->LogSystemErrorEntry(mgException.p);
}*/
}
}
}
}
/* spliting a xM to x and M */
void SplitFrequency(const string& aTimesFreq, int& aTimes, string& aFreq)
{
size_t vLen = aTimesFreq.length();
if (vLen == 1)
{
aTimes = 1;
aFreq = aTimesFreq;
return;
}
aFreq = aTimesFreq.at(vLen-1);
string vTimes = aTimesFreq.substr(0, vLen-1);
aTimes = atoi(vTimes.c_str());
if (aFreq!="Y" && aFreq!="M" && aFreq!="W" && aFreq!="D")
MG_THROW("Frequency should be Y, M, W or D");
}
/* converting a CellMatrix to a MG_Vector */
MG_Vector FromCellMatrixToMGVectorDate(const CellMatrix& aCM, const size_t& aIndex)
{
if (aCM.ColumnsInStructure()!=1 && aCM.RowsInStructure()!=1)
MG_THROW("CellMatrix should be a one row or column structure");
bool vIsRow = aCM.ColumnsInStructure() == 1;
size_t vSize = vIsRow ? aCM.RowsInStructure() : aCM.ColumnsInStructure();
MG_Vector vRes(vSize);
if (vIsRow)
{
for(size_t i=0; i<vSize; ++i)
vRes[i] = FromXLDateToJulianDay(aCM(i, aIndex).NumericValue());
return vRes;
}
for(size_t i=0; i<vSize; ++i)
vRes[i] = FromXLDateToJulianDay(aCM(aIndex, i).NumericValue());
return vRes;
}
/* converting a CellMatrix to a std::vector<double> */
vector<double> FromCellMatrixToVectorDouble(const CellMatrix& aCM, const size_t& aIndex)
{
if (aCM.ColumnsInStructure()!=1 && aCM.RowsInStructure()!=1)
MG_THROW("CellMatrix should be a one row or column structure");
bool vIsRow = aCM.ColumnsInStructure() == 1;
size_t vSize = vIsRow ? aCM.RowsInStructure() : aCM.ColumnsInStructure();
vector<double> vRes(vSize);
if (vIsRow)
{
for(size_t i=0; i<vSize; ++i)
vRes[i] = aCM(i, aIndex).NumericValue();
return vRes;
}
for(size_t i=0; i<vSize; ++i)
vRes[i] = aCM(aIndex, i).NumericValue();
return vRes;
}