IAttributeHistory * CreateDiskAttributeHistory(const boost::filesystem::path & path, const IAttribute * attribute, int version) { static CacheT<std::_tstring, CDiskAttributeHistory> AttributeHistoryCache; CDiskAttributeHistory * attr = AttributeHistoryCache.Get(new CDiskAttributeHistory(path, const_cast<IAttribute *>(attribute), version)); ATLASSERT(attr); attr->Update(); return attr; }
CModule * CreateModuleRaw(const IRepository *rep, const std::_tstring & label, bool placeholder) { CModuleHelper modHelper(label); StdStringVector tokens; modHelper.GetQualifiedLabel(tokens); CModule * retVal = NULL; std::_tstring qualifiedLabel; for (StdStringVector::iterator itr = tokens.begin(); itr != tokens.end(); ++itr) { if (!qualifiedLabel.empty()) qualifiedLabel += CModuleHelper::DELIMTER; qualifiedLabel += *itr; retVal = ModuleCache.Get(new CModule(rep, retVal, qualifiedLabel.c_str(), *itr, placeholder)); } return retVal; }
void DeleteModule(CModule * module) { ModuleCache.Clear(module->GetCacheID()); }
CCluster * CreateClusterRaw(const CString & url, const CString & wuid, const std::_tstring & queue = _T("")) { return ClusterCache.Get(new CCluster(static_cast<const TCHAR *>(url), static_cast<const TCHAR *>(wuid), queue)); }
CResult * CreateResultRaw(const CString & url, const CString & wuid, int sequence) { return ResultCache.Get(new CResult(url, wuid, sequence)); }
void ClearModuleCache() { ATLTRACE(_T("Module cache before clearing(size=%u)\r\n"), ModuleCache.Size()); ModuleCache.Clear(); }
namespace Dali { typedef std::map<std::_tstring, std::_tstring> StringStringMap; class CResult : public IResult, public clib::CLockableUnknown, public boost::noncopyable { protected: CString m_id; CString m_url; CString m_wuid; CString m_name; int m_sequence; CString m_value; CString m_link; CString m_fileName; bool IsSupplied; __int64 m_total; StringStringMap m_schemaMap; public: IMPLEMENT_CLOCKABLEUNKNOWN; CResult() { ATLASSERT(false); } CResult(const CString & url, const CString & wuid, int sequence) : m_url(url), m_wuid(wuid), m_sequence(sequence) { m_id = m_url + _T("/") + m_wuid + _T("/") + boost::lexical_cast<std::_tstring>(sequence).c_str(); m_total = 0; } virtual ~CResult() { } const TCHAR *GetID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } const TCHAR * GetCacheID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } const TCHAR *GetName() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_name; } int GetSequence() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_sequence; } const TCHAR *GetValue() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_value; } const TCHAR *GetLink() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_link; } const TCHAR *GetFileName() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_fileName; } __int64 GetTotal() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_total; } const TCHAR *GetECLType(const std::_tstring & colID) const { clib::recursive_mutex::scoped_lock proc(m_mutex); StringStringMap::const_iterator found = m_schemaMap.find(colID); if (found != m_schemaMap.end()) { return found->second.c_str(); } return NULL; } unsigned GetResultData(__int64 start, int count, ITable * result) const { clib::recursive_mutex::scoped_lock proc(m_mutex); __int64 total; unsigned retVal = GetResultData(start, count, result, total); if (m_total && m_total < total) total = m_total; return retVal; } unsigned GetResultData(__int64 start, int count, ITable * result, __int64 & total) const { clib::recursive_mutex::scoped_lock proc(m_mutex); StlLinked<IDali> dali; dali = AttachDali((const TCHAR *)m_url, _T("Dali")); unsigned retVal = dali->GetResultData(m_wuid, m_sequence, start, count, result, total); if (m_total && m_total < total) total = m_total; return retVal; } #if _COMMS_VER < 68200 void Update(const ECLResult * c) { clib::recursive_mutex::scoped_lock proc(m_mutex); #if _COMMS_VER < 700000 m_name = CW2T(c->Name, CP_UTF8); m_sequence = c->Sequence; m_value = CW2T(c->Value, CP_UTF8); m_link = CW2T(c->Link, CP_UTF8); IsSupplied = c->IsSupplied; m_total = c->Total; #else m_name = CW2T(c->ResultName, CP_UTF8); m_sequence = c->SequenceNumber; //m_value = CW2T(c->Value, CP_UTF8); //m_link = CW2T(c->Link, CP_UTF8); m_total = c->TotalRowCount; #endif m_fileName = CW2T(c->FileName, CP_UTF8); } #else void Update(const ns6__ECLResult * c) { clib::recursive_mutex::scoped_lock proc(m_mutex); SAFE_ASSIGN2CSTRING(m_name, c->Name); SAFE_ASSIGN(m_sequence, c->Sequence); SAFE_ASSIGN2CSTRING(m_value, c->Value); SAFE_ASSIGN2CSTRING(m_link, c->Link); SAFE_ASSIGN(IsSupplied, c->IsSupplied); SAFE_ASSIGN(m_total, c->Total); SAFE_ASSIGN2CSTRING(m_fileName, c->FileName); if (c->ECLSchemas) { m_schemaMap.clear(); for(std::size_t i = 0; i < c->ECLSchemas->ECLSchemaItem.size(); ++i) { if (c->ECLSchemas->ECLSchemaItem[i]->ColumnName && c->ECLSchemas->ECLSchemaItem[i]->ColumnType) { m_schemaMap[*c->ECLSchemas->ECLSchemaItem[i]->ColumnName] = *c->ECLSchemas->ECLSchemaItem[i]->ColumnType; } } } } #endif }; static CacheT<std::_tstring, CResult> ResultCache; void ClearResultCache() { ATLTRACE(_T("Result cache before clearing(size=%u)\r\n"), ResultCache.Size()); ResultCache.Clear(); } CResult * CreateResultRaw(const CString & url, const CString & wuid, int sequence) { return ResultCache.Get(new CResult(url, wuid, sequence)); } IResult * CreateResult(const CString & url, const CString & wuid, int sequence) { return CreateResultRaw(url, wuid, sequence); } #if _COMMS_VER < 68200 IResult * CreateResult(const CString & url, const CString & wuid, const ECLResult * result) { #if _COMMS_VER < 700000 CComPtr<CResult> attr = CreateResultRaw(url, wuid, result->Sequence); #else CComPtr<CResult> attr = CreateResultRaw(url, wuid, result->SequenceNumber); #endif ATLASSERT(attr); attr->Update(result); return attr; } #else IResult * CreateResult(const CString & url, const CString & wuid, const ns6__ECLResult * result) { CComPtr<CResult> attr = CreateResultRaw(url, wuid, *result->Sequence); ATLASSERT(attr); attr->Update(result); return attr; } #endif } //namespace Dali
void ClearResultCache() { ATLTRACE(_T("Result cache before clearing(size=%u)\r\n"), ResultCache.Size()); ResultCache.Clear(); }
CLocalFile * CreateLocalFileRaw(const CString & url, const CString & wuid, const CString & source) { return LocalFileCache.Get(new CLocalFile(url, wuid, source)); }
void ClearClusterSingletons() { ClusterCache.clear(); }
void ClearClusterCache() { ClusterCache.Clear(); }
bool GetActive(IClusterVector * clusters) { CComInitialize com; ServerT server; CString url = GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_SERVER_SMC); server.SetUrl(url); CStructArrayOut<ActiveWorkunit> running; #if _COMMS_VER < 499 bool thorQueueManagement; if (server.Index(exceptions.GetArrayAddress(), exceptions.GetCountAddress(), &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), &thorQueueManagement) == S_OK) #elif _COMMS_VER < 505 bool thorQueueManagement; CStructArrayOut<ActiveWorkunit> running; if (server.Index(exceptions.GetArrayAddress(), exceptions.GetCountAddress(), &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), running.GetArrayAddress(), running.GetCountAddress(), &thorQueueManagement) == S_OK) #elif _COMMS_VER < 50509 CStructArrayOut<ActiveWorkunit> running; if (server.Index(exceptions.GetArrayAddress(), exceptions.GetCountAddress(), &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), running.GetArrayAddress(), running.GetCountAddress()) == S_OK) #elif _COMMS_VER < 51100 CStructArrayOut<ActiveWorkunit> running; if (server.Activity(false, exceptions.GetArrayAddress(), exceptions.GetCountAddress(), &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), running.GetArrayAddress(), running.GetCountAddress()) == S_OK) #elif _COMMS_VER < 67205 CComBSTR build; CStructArrayOut<ThorCluster> thorClusters; CStructArrayOut<HoleCluster> holeClusters; CStructArrayOut<DFUJob> dfuJobs; ESP_EXCEPTION_LOG(EspException); if (server.Activity(exceptions.GetArrayAddress(), exceptions.GetCountAddress(), &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), running.GetArrayAddress(), running.GetCountAddress()) == S_OK) { if (build) m_version = CreateVersion(url, CString(build)); // Multi thor support - there could be some jobs running on a multi thor! for(int i = 0; i < running.GetCount(); ++i) { CComBSTR thorClusterName = running.GetItem(i)->Instance; #elif _COMMS_VER < 700000 CComBSTR build; CStructArrayOut<ThorCluster> thorClusters; CStructArrayOut<HoleCluster> holeClusters; CStructArrayOut<DFUJob> dfuJobs; ESP_EXCEPTION_LOG2(EspException); if (server.Activity(exceptions, &build, thorClusters.GetArrayAddress(), thorClusters.GetCountAddress(), holeClusters.GetArrayAddress() , holeClusters.GetCountAddress(), dfuJobs.GetArrayAddress(), dfuJobs.GetCountAddress(), running.GetArrayAddress(), running.GetCountAddress()) == S_OK) { if (build) m_version = CreateVersion(url, CString(build)); // Multi thor support - there could be some jobs running on a multi thor! for(int i = 0; i < running.GetCount(); ++i) { CComBSTR thorClusterName = running.GetItem(i)->Instance; #else ESP_STATUS_LOG; if (server.ListActiveOrQueuedWorkunits(running.GetArrayAddress(), running.GetCountAddress(), &status.m_statusCode, &status.m_statusMessage) == S_OK) { // Multi thor support - there could be some jobs running on a multi thor! for(int i = 0; i < running.GetCount(); ++i) { CComBSTR thorClusterName = running.GetItem(i)->ServerInstance; #endif CComBSTR thorClusterStatus = running.GetItem(i)->State; ThorCluster thorCluster; thorCluster.ClusterName = thorClusterName; thorCluster.QueueStatus = thorClusterStatus; StlLinked<ICluster> cluster = CreateCluster(m_url, &thorCluster, running); if (std::find(clusters->begin(), clusters->end(), cluster) == clusters->end()) { clusters->push_back(cluster.get()); } } return true; } else _DBGLOG(m_url, LEVEL_WARNING, server.GetClientError()); return false; } IVersion * GetBuild() { if (m_version) return m_version; IClusterVector results; if (GetActive(&results)) return m_version; return m_unknown; } bool SetPriority(const std::_tstring &cluster, const std::_tstring &wuid, PRIORITY priority) { CComInitialize com; ServerT server; server.SetUrl(CString(GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_SERVER_SMC))); CComBSTR inCluster = CT2W(cluster.c_str(), CP_UTF8); CComBSTR inWuid = CT2W(wuid.c_str(), CP_UTF8); HRESULT result; #if _COMMS_VER < 67205 ESP_EXCEPTION_LOG(EspException); #elif _COMMS_VER < 700000 ESP_EXCEPTION_LOG2(EspException); #else ESP_STATUS_LOG; #endif switch (priority) { case PRIORITY_UP: { #if _COMMS_VER < 51100 result = server.MoveJobUp(inCluster, inWuid); #elif _COMMS_VER < 67205 result = server.MoveJobUp(inCluster, inWuid, exceptions.GetArrayAddress(), exceptions.GetCountAddress()); #elif _COMMS_VER < 700000 result = server.MoveJobUp(inCluster, inWuid, exceptions); #else CComBSTR position = _T("up"); result = server.SetWorkunitPositionInSamePriority(inCluster, inWuid, position, &status.m_statusCode, &status.m_statusMessage); #endif } break; case PRIORITY_DOWN: { #if _COMMS_VER < 51100 result = server.MoveJobDown(inCluster, inWuid); #elif _COMMS_VER < 67205 result = server.MoveJobDown(inCluster, inWuid, exceptions.GetArrayAddress(), exceptions.GetCountAddress()); #elif _COMMS_VER < 700000 result = server.MoveJobDown(inCluster, inWuid, exceptions); #else CComBSTR position = _T("down"); result = server.SetWorkunitPositionInSamePriority(inCluster, inWuid, position, &status.m_statusCode, &status.m_statusMessage); #endif } break; case PRIORITY_TOP: { #if _COMMS_VER < 51100 result = server.MoveJobFront(inCluster, inWuid); #elif _COMMS_VER < 67205 result = server.MoveJobFront(inCluster, inWuid, exceptions.GetArrayAddress(), exceptions.GetCountAddress()); #elif _COMMS_VER < 700000 result = server.MoveJobFront(inCluster, inWuid, exceptions); #else CComBSTR position = _T("front"); result = server.SetWorkunitPositionInSamePriority(inCluster, inWuid, position, &status.m_statusCode, &status.m_statusMessage); #endif } break; case PRIORITY_BOTTOM: { #if _COMMS_VER < 51100 result = server.MoveJobBack(inCluster, inWuid); #elif _COMMS_VER < 67205 result = server.MoveJobBack(inCluster, inWuid, exceptions.GetArrayAddress(), exceptions.GetCountAddress()); #elif _COMMS_VER < 700000 result = server.MoveJobBack(inCluster, inWuid, exceptions); #else CComBSTR position = _T("end"); result = server.SetWorkunitPositionInSamePriority(inCluster, inWuid, position, &status.m_statusCode, &status.m_statusMessage); #endif } break; default: _DBGLOG(m_url, LEVEL_WARNING, server.GetClientError()); return false; } if(result == S_OK) { return true; } else _DBGLOG(m_url, LEVEL_WARNING, server.GetClientError()); return false; } bool SetPriority(Dali::IWorkunitVector *workunits, PRIORITY priority) { switch (priority) { case PRIORITY_UP: case PRIORITY_TOP: { for(Dali::IWorkunitVector::iterator itr = workunits->begin(); itr != workunits->end(); ++itr) { Dali::IWorkunitAdapt& workunit = *itr; SetPriority(workunit->GetCluster(), workunit->GetWuid(), priority); } } break; case PRIORITY_DOWN: case PRIORITY_BOTTOM: { for (Dali::IWorkunitVector::reverse_iterator itr = workunits->rbegin(); itr != workunits->rend(); ++itr) { Dali::IWorkunitAdapt& workunit = *itr; SetPriority(workunit->GetCluster(), workunit->GetWuid(), priority); } } break; } return true; } }; #endif CacheT<std::_tstring, CSMC> SMCCache; ISMC * AttachSMC(const std::_tstring & url, const std::_tstring & label) { return SMCCache.Get(new CSMC(url.c_str(), label.c_str())); } COMMS_API ISMC * AttachSMC(const _variant_t & url, const std::_tstring & label) { return SMCCache.Get(new CSMC(url, label.c_str())); } void ClearSingletons() { ClearVersionCache(); ClearClusterCache(); SMCCache.clear(); } }
namespace Topology { class CDropZone : public IDropZone, public CUnknown { protected: std::_tstring m_Url; std::_tstring m_Name; std::_tstring m_Path; std::_tstring m_Build; std::_tstring m_Description; StlLinked<CMachine> m_machine; //only 1 per drop zone I think public: IMPLEMENT_CUNKNOWNQI(IDropZone); CDropZone(const TCHAR* url, const TCHAR* name, const TCHAR* path) : m_Url(url), m_Name(name), m_Path(path) { } virtual ~CDropZone() { } public: //IDropZone const TCHAR *GetID() const { return m_Name.c_str(); } const TCHAR * GetCacheID() const { return m_Name.c_str(); } const TCHAR *GetName(std::_tstring &name) const { name = m_Name; return name.c_str(); } const TCHAR *GetDescription(std::_tstring &desc) const { desc = m_Description; return desc.c_str(); } const TCHAR *GetPath(std::_tstring &path) const { path = m_Path; return path.c_str(); } const TCHAR *GetBuild(std::_tstring &build) const { build = m_Build; return build.c_str(); } IMachine *GetMachine() const { return m_machine.get(); } #if _COMMS_VER < 68200 void Update(const TpDropZone * c) { m_Name = CW2T(c->Name, CP_UTF8); m_Description = CW2T(c->Description, CP_UTF8); m_Path = CW2T(c->Path, CP_UTF8); m_Build = CW2T( c->Build, CP_UTF8); m_machine = new CMachine(); #if _COMMS_VER < 60000 m_machine->Update(c->TpMachines); #else m_machine->Update(c->TpMachines._TpMachine); #endif Refresh(); } #elif _COMMS_VER < 700000 void Update(const ns5__TpDropZone * c) { SAFE_ASSIGN(m_Name, c->Name); SAFE_ASSIGN(m_Description, c->Description); SAFE_ASSIGN(m_Path, c->Path); SAFE_ASSIGN(m_Build, c->Build); m_machine = new CMachine(); m_machine->Update(c->TpMachines->TpMachine[0]); Refresh(); } #else void Update(const ServiceDetail * c) { m_Name = CW2T(c->Name, CP_UTF8); m_Description = CW2T(c->Description, CP_UTF8); //m_Path = CW2T(c->Path, CP_UTF8); m_Build = CW2T( c->Build, CP_UTF8); m_machine = new CMachine(); m_machine->Update(c->Machines._Machine); Refresh(); } #endif void Refresh() { } }; CacheT<std::_tstring, CDropZone> DropZoneCache; CDropZone * CreateDropZoneRaw(const TCHAR *url, const TCHAR *name, const TCHAR *path) { return DropZoneCache.Get(new CDropZone(url, name, path)); } IDropZone * CreateDropZone(const TCHAR *url, const TCHAR *name, const TCHAR *path) { return CreateDropZoneRaw(url, name, path); } #if _COMMS_VER < 68200 IDropZone * CreateDropZone(const CString & url, const TpDropZone * data) { CDropZone * zone = CreateDropZoneRaw(url, CW2T(data->Name, CP_UTF8), CW2T(data->Path, CP_UTF8)); ATLASSERT(zone); zone->Update(data); return zone; } #elif _COMMS_VER < 700000 IDropZone * CreateDropZone(const CString & url, const ns5__TpDropZone * data) { CDropZone * zone = CreateDropZoneRaw(url, data->Name->c_str(), data->Path->c_str()); ATLASSERT(zone); zone->Update(data); return zone; } #else IDropZone * CreateDropZone(const CString & url, const ServiceDetail * data) { CDropZone * zone = CreateDropZoneRaw(url, CW2T(data->Name, CP_UTF8), CW2T(_T(""), CP_UTF8)); ATLASSERT(zone); zone->Update(data); return zone; } #endif void ClearDropZoneSingletons() { DropZoneCache.clear(); } }
void ClearDropZoneSingletons() { DropZoneCache.clear(); }
CDropZone * CreateDropZoneRaw(const TCHAR *url, const TCHAR *name, const TCHAR *path) { return DropZoneCache.Get(new CDropZone(url, name, path)); }
namespace Dali { class CLocalResult : public IResult, public clib::CLockableUnknown, public boost::noncopyable { protected: CString m_id; CString m_url; CString m_wuid; CString m_name; int m_sequence; CString m_value; CString m_link; CString m_fileName; bool IsSupplied; __int64 m_total; StlLinked<ITable> m_result; public: IMPLEMENT_CLOCKABLEUNKNOWN; CLocalResult() { ATLASSERT(false); } CLocalResult(const CString & url, const CString & wuid, int sequence) : m_url(url), m_wuid(wuid), m_sequence(sequence) { m_id = m_url + _T("/") + m_wuid + _T("/") + boost::lexical_cast<std::_tstring>(sequence).c_str(); m_total = 0; m_result = CreateISparseTable(); //m_result->AddColumn(_T("Row")); } virtual ~CLocalResult() { } const TCHAR *GetID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } const TCHAR * GetCacheID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } const TCHAR *GetName() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_name; } int GetSequence() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_sequence; } const TCHAR *GetValue() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_value; } const TCHAR *GetLink() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_link; } const TCHAR *GetFileName() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_fileName; } __int64 GetTotal() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_total; } const TCHAR *GetECLType(const std::_tstring & colID) const { return NULL; } unsigned GetResultData(__int64 start, int count, ITable * result) const { clib::recursive_mutex::scoped_lock proc(m_mutex); __int64 total; unsigned retVal = GetResultData(start, count, result, total); if (m_total && m_total < total) total = m_total; return retVal; } unsigned GetResultData(__int64 start, int count, ITable * result, __int64 & total) const { clib::recursive_mutex::scoped_lock proc(m_mutex); if (m_result->GetRowCount() - start < count) count = m_result->GetRowCount() - start; for(__int64 i = start; i < start + count; ++i) { for (unsigned int j = 0; j < m_result->GetColumnCount(); ++j) { int newCol = result->FindColumn(m_result->GetColumn(j), true, m_result->GetColumnType(j)); if (newCol >= 0) result->SetCell(i, newCol, m_result->GetCell(i, j)); else result->SetCell(i, j, m_result->GetCell(i, j)); } } return count; } void Update(const std::_tstring & name, ITable * result) { clib::recursive_mutex::scoped_lock proc(m_mutex); m_name = name.c_str(); m_result->LoadFrom(result); m_total = result->GetRowCount(); } }; static CacheT<std::_tstring, CLocalResult> LocalResultCache; void ClearLocalResultCache() { ATLTRACE(_T("Result cache before clearing(size=%u)\r\n"), LocalResultCache.Size()); LocalResultCache.Clear(); } CLocalResult * CreateLocalResultRaw(const CString & url, const CString & wuid, int sequence) { return LocalResultCache.Get(new CLocalResult(url, wuid, sequence)); } IResult * CreateLocalResult(const CString & url, const CString & wuid, int sequence) { return CreateLocalResultRaw(url, wuid, sequence); } #if _COMMS_VER < 68200 #else IResult * CreateLocalResult(const CString & url, const CString & wuid, const std::_tstring & label, int sequence, ITable * result) { CComPtr<CLocalResult> attr = CreateLocalResultRaw(url, wuid, sequence); ATLASSERT(attr); attr->Update(label, result); return attr; } #endif } //namespace Dali
namespace Dali { #if _COMMS_VER < 60600 #else class CLocalFile : public ILocalFile, public clib::CLockableUnknown, public boost::noncopyable { protected: CString m_id; CString m_url; CString m_wuid; int m_type; CString m_source; CString m_destination; localfile_signal_type on_refresh; public: IMPLEMENT_CLOCKABLEUNKNOWN; CLocalFile() { ATLASSERT(false); } CLocalFile(const CString & url, const CString & wuid, const CString & source) : m_url(url), m_wuid(wuid), m_source(source) { m_id = m_url + _T("/") + m_wuid + _T("/") + m_source; m_type = 0; } virtual ~CLocalFile() { } const TCHAR *GetID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } const TCHAR * GetCacheID() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_id; } int GetType() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_type; } const TCHAR *GetSource() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_source; } const TCHAR *GetDestination() const { clib::recursive_mutex::scoped_lock proc(m_mutex); return m_destination; } #if _COMMS_VER < 68200 void Update(const LogicalFileUpload * c) { clib::recursive_mutex::scoped_lock proc(m_mutex); bool changed = false; if (m_source.Compare(CW2T(c->Source, CP_UTF8)) != 0 || m_destination.Compare(CW2T(c->Destination, CP_UTF8)) != 0 || m_type != c->Type) { changed = true; } m_type = c->Type; m_source = CW2T(c->Source, CP_UTF8); m_destination = CW2T(c->Destination, CP_UTF8); if (changed) { proc.unlock(); Refresh(); } } #else void Update(const ns6__LogicalFileUpload * c) { clib::recursive_mutex::scoped_lock proc(m_mutex); CString prev_source = m_source; CString prev_destinition = m_destination; int prev_type = m_type; SAFE_ASSIGN2CSTRING(m_source, c->Source); SAFE_ASSIGN2CSTRING(m_destination, c->Destination); SAFE_ASSIGN(m_type, c->Type); if (m_source.Compare(prev_source) != 0 || m_destination.Compare(prev_destinition) != 0 || m_type != prev_type) { proc.unlock(); Refresh(); } } #endif void Refresh() { on_refresh(this); } boost::signals::connection on_refresh_connect(const localfile_slot_type& s) { clib::recursive_mutex::scoped_lock proc(m_mutex); return on_refresh.connect(s); } }; static CacheT<std::_tstring, CLocalFile> LocalFileCache; void ClearLocalFileCache() { ATLTRACE(_T("LocalFile cache before clearing(size=%u)\r\n"), LocalFileCache.Size()); LocalFileCache.Clear(); } CLocalFile * CreateLocalFileRaw(const CString & url, const CString & wuid, const CString & source) { return LocalFileCache.Get(new CLocalFile(url, wuid, source)); } ILocalFile * CreateLocalFile(const CString & url, const CString & wuid, const CString & source) { return CreateLocalFileRaw(url, wuid, source); } #if _COMMS_VER < 68200 ILocalFile * CreateLocalFile(const CString & url, const CString & wuid, const LogicalFileUpload * localfile) { CComPtr<CLocalFile> lf = CreateLocalFileRaw(url, wuid, localfile->Source); ATLASSERT(lf); lf->Update(localfile); return lf; } #else ILocalFile * CreateLocalFile(const CString & url, const CString & wuid, const ns6__LogicalFileUpload * localfile) { CComPtr<CLocalFile> lf = CreateLocalFileRaw(url, wuid, localfile->Source->c_str()); ATLASSERT(lf); lf->Update(localfile); return lf; } #endif #endif } //namespace Dali
namespace Topology { class CCluster : public ICluster, public CUnknown { protected: std::_tstring m_Name; std::_tstring m_Queue; std::_tstring m_Url; std::_tstring m_Type; std::_tstring m_Directory; std::_tstring m_Desc; std::_tstring m_Prefix; std::_tstring m_Path; std::_tstring m_DataModel; public: IMPLEMENT_CUNKNOWN; CCluster(const std::_tstring & url, const std::_tstring & name, const std::_tstring & queue = _T("")) : m_Url(url), m_Name(name), m_Queue(queue) { } virtual ~CCluster() { } const TCHAR *GetID() const { return m_Name.c_str(); } const TCHAR * GetCacheID() const { return m_Name.c_str(); } const TCHAR *GetName() const { return m_Name.c_str(); } const TCHAR *GetQueue() const { return m_Queue.c_str(); } const TCHAR *GetType() const { return m_Type.c_str(); } const TCHAR *GetDirectory() const { return m_Directory.c_str(); } const TCHAR *GetDesc() const { return m_Desc.c_str(); } const TCHAR *GetPrefix() const { return m_Prefix.c_str(); } const TCHAR *GetPath() const { return m_Path.c_str(); } const TCHAR *GetDataModel() const { return m_DataModel.c_str(); } #if _COMMS_VER < 68200 void Update(const TpLogicalCluster * c) { m_Name = CW2T(c->Name, CP_UTF8); #if _COMMS_VER < 55100 #else if(c->Queue) { m_Queue = CW2T(c->Queue, CP_UTF8); } #endif Refresh(); } void Update(const TpCluster * c) { m_Name = CW2T(c->Name, CP_UTF8); m_Type = CW2T(c->Type, CP_UTF8); m_Directory = CW2T(c->Directory, CP_UTF8); m_Desc = CW2T(c->Desc, CP_UTF8); m_Prefix = CW2T(c->Prefix, CP_UTF8); m_Path = CW2T(c->Path, CP_UTF8); m_DataModel = CW2T(c->DataModel, CP_UTF8); Refresh(); } #elif _COMMS_VER < 700000 void Update(const ns5__TpLogicalCluster * c) { SAFE_ASSIGN(m_Name, c->Name); SAFE_ASSIGN(m_Queue, c->Queue); Refresh(); } #else void Update(const LogicalCluster * c) { m_Name = CW2T(c->Name, CP_UTF8); if(c->Queue) { m_Queue = CW2T(c->Queue, CP_UTF8); } Refresh(); } #endif void Refresh() { } }; CacheT<std::_tstring, CCluster> ClusterCache; void ClearClusterCache() { ClusterCache.Clear(); } CCluster * CreateClusterRaw(const CString & url, const CString & wuid, const std::_tstring & queue = _T("")) { return ClusterCache.Get(new CCluster(static_cast<const TCHAR *>(url), static_cast<const TCHAR *>(wuid), queue)); } ICluster * CreateCluster(const CString & url, const CString & wuid, const std::_tstring & queue) { return CreateClusterRaw(url, wuid, queue); } #if _COMMS_VER < 68200 ICluster * CreateCluster(const CString & url, const TpLogicalCluster * data) { CCluster * attr = CreateClusterRaw(url, data->Name); ATLASSERT(attr); attr->Update(data); return attr; } ICluster * CreateCluster(const CString & url, const TpCluster * data) { ATLASSERT(!"This is not used any more - please tell Gordon"); //CCluster * attr = CreateClusterRaw(url, data->Name); //ATLASSERT(attr); //attr->Update(data); return NULL;//attr; } #elif _COMMS_VER < 700000 ICluster * CreateCluster(const CString & url, const ns5__TpLogicalCluster * data) { CCluster * attr = CreateClusterRaw(url, data->Name->c_str()); ATLASSERT(attr); attr->Update(data); return attr; } ICluster * CreateCluster(const CString & url, const ns5__TpCluster * data) { ATLASSERT(!"This is not used any more - please tell Gordon"); //CCluster * attr = CreateClusterRaw(url, data->Name); //ATLASSERT(attr); //attr->Update(data); return NULL;//attr; } #else ICluster * CreateCluster(const CString & url, const LogicalCluster * data) { CCluster * attr = CreateClusterRaw(url, data->Name); ATLASSERT(attr); attr->Update(data); return attr; } ICluster * CreateCluster(const CString & url, const Cluster * data) { ATLASSERT(!"This is not used any more - please tell Gordon"); //CCluster * attr = CreateClusterRaw(url, data->Name); //ATLASSERT(attr); //attr->Update(data); return NULL;//attr; } #endif void ClearClusterSingletons() { ClusterCache.clear(); } }
void ClearLocalFileCache() { ATLTRACE(_T("LocalFile cache before clearing(size=%u)\r\n"), LocalFileCache.Size()); LocalFileCache.Clear(); }