_variant_t Get(const std::_tstring & section, const std::_tstring & label, const _variant_t & defaultVal)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
SectionLabelDefault sl(SectionLabel(section, label), defaultVal);
ConfigCacheT::const_iterator found = m_cache.find(sl.first);
if(sl == GLOBAL_USER && found != m_cache.end())
if (!CString(m_cache[sl.first]).IsEmpty())
return m_cache[sl.first];
if(sl == GLOBAL_PASSWORD && found != m_cache.end())
if (!CString(m_cache[sl.first]).IsEmpty())
return m_cache[sl.first];
if (!m_CfgPath.empty())
{
if (found != m_cache.end())
return found->second;
CString _defaultVal = defaultVal, _val;
if (!m_Cfg.GetString(section.c_str(), label.c_str(), _val, _defaultVal))
{
//ATLTRACE(_T("GetString(%s,%s,Err=%x)\r\n"), section, label, ::GetLastError() );
_val = _defaultVal;
}
SectionLabel id(section, label);
if (CString(m_cache[id]).CompareNoCase(_val) != 0)
{
m_cache[id] = _val;
_variant_t retVal = m_cache[sl.first];
proc.unlock();
on_refresh(&id);
return retVal;
}
}
return m_cache[sl.first];
}
// ===========================================================================
void TextCompare(const std::_tstring & base, const std::_tstring & comp, CLineVector & baseResult, CLineVector & compResult)
{
if (base.length() == 0 && comp.length() == 0)
return;
CTable baseTable(base);
CTable compTable(comp);
CAnchors compare(baseTable, compTable, 1);
compare.GetPaddedResults(baseResult, compResult);
}
void CMainFrame::ShowDiff(const std::_tstring & lhs, const std::_tstring & lhsHeader, const std::_tstring & rhs, const std::_tstring & rhsHeader)
{
m_sourceEclView.SetReadOnly(false);
m_sourceEclView.SetText(lhs.c_str());
m_sourceEclView.SetReadOnly(true);
m_targetEclView.SetReadOnly(false);
m_targetEclView.SetText(rhs.c_str());
m_targetEclView.SetReadOnly(true);
m_diffView.SetText(lhs, rhs);
}
bool MessageBox(HWND hwnd, std::_tstring &error_title, std::_tstring &error_msg)
{
if (m_errExists)
{
if (::MessageBox(hwnd, error_title.c_str(), error_msg.c_str(), MB_ICONASTERISK | MB_YESNO) == IDYES)
return true;
m_errExists = false;
}
else
::MessageBox(hwnd, error_title.c_str(), error_msg.c_str(), MB_ICONASTERISK);
return false;
}
void InitConfigPath(const std::_tstring & cfgName, const std::_tstring & ext)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
m_CfgName = cfgName;
ATLASSERT((cfgName.find('.') == std::_tstring::npos));
ATLASSERT((ext.find('.') == std::_tstring::npos));
std::_tstring cfgNameExt = cfgName;
cfgNameExt += _T(".");
cfgNameExt += ext;
boost::filesystem::path appFolder;
m_CfgPath = GetApplicationFolder(appFolder) / stringToPath(cfgNameExt);
m_Cfg.SetFilename(pathToWString(m_CfgPath).c_str());
}
static void threadLoadAttribute(CWorkspaceItem * self, std::_tstring moduleLabel, std::_tstring attributeLabel, std::_tstring attributeType)
{
self->m_loaded = LOADING_STARTED;
CComPtr<IAttribute> attribute = NULL;
if (!moduleLabel.empty() && !attributeLabel.empty())
{
attribute = self->m_repository->GetAttributeFast(moduleLabel.c_str(), attributeLabel.c_str(), CreateIAttributeType(attributeType), 0, true, true, true);
if (!attribute)
attribute = self->m_repository->GetAttributePlaceholder(moduleLabel.c_str(), attributeLabel.c_str(), CreateIAttributeType(attributeType));
}
self->SetAttr(attribute);
self->m_loaded = LOADING_FINISHED;
}
void CDockableDataViews::SetTabData(const std::_tstring & label, const ITable * data, bool hasRowNum, const roxie::CSearchRowVector & searchResults)
{
StringResultMap::iterator itr = m_dataTabs.find(label);
if (itr == m_dataTabs.end())
{
m_dataTabs[label] = new CDataView();
m_dataTabs[label]->Create(NULL, label.c_str(), WS_CHILD | WS_VISIBLE, CRect(0, 0, 0, 0), &m_wndTab, 1);
m_dataTabs[label]->SetFont(&afxGlobalData.fontRegular);
m_wndTab.InsertTab(m_dataTabs[label], label.c_str(), 0, 0, FALSE);
}
m_dataTabs[label]->SetData(data, hasRowNum, searchResults);
ActivateTab(m_dataTabs[label]);
}
void CDockablePropertyGridViews::SetTabPropertyGrid(const std::_tstring & label, const ITable* data)
{
StringPropertyGridMap::const_iterator itr = m_propertyGridTabs.find(label);
if (itr == m_propertyGridTabs.end())
{
bool edges = boost::algorithm::iequals(label, _T("edges"));
StlLinked<CPropertyGridView> propertyGridView = new CPropertyGridView(edges ? XGMML_CAT_EDGE : XGMML_CAT_VERTEX);
m_propertyGridTabs[label] = propertyGridView.get();
propertyGridView->Create(NULL, label.c_str(), WS_CHILD | WS_VISIBLE, CRect(0, 0, 0, 0), &m_wndTab, 1);
propertyGridView->SetFont(&afxGlobalData.fontRegular);
m_wndTab.AddTab(propertyGridView, label.c_str(), 0, FALSE);
propertyGridView->SetOwner(m_owner);
}
m_propertyGridTabs[label]->SetData(data);
}
static WORKSPACE_ITEM_TYPE CalcType(const std::_tstring & type)
{
if (type.compare(PERSISTVAL_BUILDER) == 0)
{
return WORKSPACE_ITEM_BUILDER;
}
else if (type.compare(PERSISTVAL_ATTRIBUTE) == 0)
{
return WORKSPACE_ITEM_ATTRIBUTE;
}
else if (type.compare(PERSISTVAL_GRAPH) == 0)
{
return WORKSPACE_ITEM_GRAPH;
}
return WORKSPACE_ITEM_UNKNOWN;
}
bool GetAutoC(const std::_tstring & partialLabel, StdStringVector &set)
{
CComPtr<IRepository> rep = AttachRepository();
rep->GetModulesAutoC(partialLabel, set);
if (!partialLabel.empty())
rep->GetAttributesAutoC(partialLabel, set);
return true;
}
void Update(const std::_tstring &cluster, const std::_tstring &status, const std::vector<ns4__ActiveWorkunit *> &running)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
m_cluster = cluster.c_str();
m_queue.clear();
m_status = status.c_str();
for(std::size_t i = 0; i < running.size(); ++i)
{
if (running[i]->Instance && m_cluster.CompareNoCase(running[i]->Instance->c_str()) == 0)
{
// Creating a workunit can cause a deadlock with the active tree, so set noBroadcast to true.
CComPtr<Dali::IWorkunit> wu = Dali::CreateWorkunit(GetIConfig(QUERYBUILDER_CFG)->Get(GLOBAL_SERVER_WORKUNIT), _T("Dali"), running[i], true);
ATLASSERT(wu);
m_queue.push_back(wu.p);
}
}
}
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();
}
void ShowEcl(const std::_tstring & searchTerm, FINDMODE findmode)
{
m_tabbedChildWindow.GetTabCtrl().SetCurSel(0);
if (searchTerm.length())
{
int flags = 0;
m_dlgview.GetView().DoFind(searchTerm, flags, findmode, true);
}
}
void CTable::parse_line(const std::_tstring & table)
{
for(std::size_t i = 0; i < table.size(); ++i)
{
std::_tstring tchar;
tchar.resize(1, table[i]);
m_rows.push_back(CLine(tchar));
}
}
CWorkspaceItem(IRepository * repository, const std::_tstring & data)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
m_repository = repository;
m_props.deserializeXML(data.c_str());
m_id = m_props.Get(PERSIST_FILEPATH);
UpdateID();
m_attributeLoaded = false;
m_workunitLoaded = false;
m_loaded = LOADING_UNKNOWN;
}
std::_tstring CBookmarksView::FindTag(std::_tstring str, std::_tstring tag, int &index) {
std::_tstring tagEnd = _T("</") + tag + _T(">");
std::_tstring foundStr = _T("");
tag = _T("<") + tag + _T(">");
int n = static_cast<int>(str.find(tag, index));
if (n >= 0)
{
int tagLen = tag.length();
int indexEnd = static_cast<int>(str.find(tagEnd, index));
foundStr = str.substr(n + tagLen, indexEnd - n - tagLen);
index = indexEnd + tagEnd.length() + 1;
}
else
{
index = -1;
foundStr = _T("");
}
return foundStr;
}
CLIB_API const boost::filesystem::path & GetProgramPath(boost::filesystem::path & path)
{
TCHAR programPath[_MAX_PATH];
::GetModuleFileName(0, programPath, _MAX_PATH);
path = stringToPath(programPath);
if(!g_appName.empty())
{
path = path.branch_path() / stringToPath(g_appName);
}
return path;
}
void CLine::hash_string(const std::_tstring & s)
{
// Calc Hash
boost::crc_32_type computer;
computer.reset();
computer.process_bytes(s.c_str(), sizeof(TCHAR) * s.length());
m_hash = computer.checksum();
// Calc Anchor Hash
bool prevIsGraph = true;
static boost::crc_32_type anchorComputer;
anchorComputer.reset();
for (unsigned int i = 0; i < s.length(); ++i)
{
bool isGraph = iswgraph(s[i]) != 0 || s[i] == '\r' || s[i] == '\n';
if (isGraph)
anchorComputer.process_bytes(&s[i], sizeof(TCHAR));
prevIsGraph = isGraph;
}
m_anchorHash = anchorComputer.checksum();
}
unsigned GetModules(const std::_tstring & module, IModuleVector & modules, bool GetChecksum = false, bool noRefresh=false) const
{
IModuleVector allModules;
GetAllModules(allModules, GetChecksum, noRefresh);
for(IModuleVector::iterator itr = allModules.begin(); itr != allModules.end(); ++itr)
{
IModule * parent = itr->get()->GetParentModule();
if ((!parent && module.empty()) || (parent && boost::algorithm::equals(module, parent->GetQualifiedLabel())))
modules.push_back(itr->get());
}
return 0;
}
bool IsValidIdentifier(const std::_tstring & label)
{
if (label.size() == 0)
return false;
for (std::_tstring::size_type i = 0; i < label.size(); ++i)
{
switch (label.at(i))
{
case '<':
case '>':
case ':':
case '\"':
case '/':
case '\\':
case '|':
case '?':
case '*':
case '.':
return false;
}
}
return true;
}
void Set(const std::_tstring & section, const std::_tstring & label, const _variant_t & val)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
SectionLabelDefault sl(SectionLabel(section, label), _T(""));
if(sl == GLOBAL_USER)
{
InitConfigPath(m_CfgName, _T("cfg"));
}
SectionLabel id(section, label);
if (m_cache.find(id) == m_cache.end() || CString(m_cache[id]).CompareNoCase(CString(val)) != 0)
{
if (!m_CfgPath.empty() && sl != GLOBAL_PASSWORD)
{
CString _val = val;
if ( !m_Cfg.PutString(section.c_str(), label.c_str(), _val) )
{
ATLTRACE(_T("PutString(%s,%s,Err=%x)\r\n"), section, label, ::GetLastError() );
}
}
m_cache[id] = val;
proc.unlock();
on_refresh(&id);
}
}
void CTable::parse_rows(const std::_tstring & table)
{
std::_tstring line;
for(std::size_t i = 0; i < table.size(); ++i)
{
line += table[i];
if (table[i] == _T('\n'))
{
m_rows.push_back(CLine(line));
line = _T("");
}
}
if (line.size())
m_rows.push_back(CLine(line));
}
bool OnOk(const std::_tstring & label, std::_tstring &error_title, std::_tstring &error_msg)
{
CComPtr<IRepository> rep = ::AttachRepository();
std::_tstring error;
if (rep->Label(label.c_str(), error))
{
if (!error.length())
{
return true;
}
}
error_title = ERR_INVALID_IDENTIFIER_TITLE;
error_msg = error;
return false;
}
void CDockableDataViews::SetTabEcl(const std::_tstring & localFile, int row, const CUniqueID & id)
{
std::_tstring label = localFile;
StringSourceMap::iterator itr = m_sourceTabs.find(localFile);
if (itr == m_sourceTabs.end())
{
StlLinked<CLocalDataView> attributeDataView = new CLocalDataView();
m_sourceTabs[localFile] = attributeDataView.get();
attributeDataView->Create(NULL, localFile.c_str(), WS_CHILD | WS_VISIBLE, CRect(0, 0, 0, 0), &m_wndTab, 1);
attributeDataView->SetFont(&afxGlobalData.fontRegular);
boost::filesystem::path p = stringToPath(localFile);
m_wndTab.AddTab(attributeDataView, pathToWString(p.filename()).c_str(), 0, FALSE);
attributeDataView->SetOwner(m_owner);
attributeDataView->SetSource(localFile);
}
m_sourceTabs[localFile]->SetBreakpointLocation(row, id);
}
const TCHAR * ToCSV(std::_tstring & line)
{
// Keep in sync with "CLanguageReference(const std::vector<std::_tstring> & fields)" ---
std::_tstring encoded;
line += EncodeForCSV(categoryid.c_str(), encoded); line += _T(",");
line += EncodeForCSV(name.c_str(), encoded); line += _T(",");
line += EncodeForCSV(tooltip.c_str(), encoded); line += _T(",");
line += EncodeForCSV(insertbeforecursor.c_str(), encoded); line += _T(",");
line += EncodeForCSV(insertaftercursor.c_str(), encoded); line += _T(",");
line += EncodeForCSV(canbefollowedby.c_str(), encoded);
return line.c_str();
}
bool OnOk(const std::_tstring & label, IAttributeType * type, std::_tstring &error_title, std::_tstring &error_msg)
{
if (IsValidIdentifier(label))
{
CComPtr<IRepository> rep = ::AttachRepository();
ATLASSERT(m_module.length());
if (!rep->AttributeExists(m_module.c_str(), label.c_str(), type))
{
return true;
}
error_title = ERR_INVALID_IDENTIFIER_TITLE;
error_msg = ERR_IDENTIFIER_EXISTS_AS_ATTRIBUTE;
}
else
{
error_title = ERR_INVALID_IDENTIFIER_TITLE;
error_msg = ERR_INVALID_IDENTIFIER;
}
return false;
}
void CWizardSprayAnalyze::LogMessage(const std::_tstring &msg)
{
m_analyzeStatus.AppendText(msg.c_str());
}
void CRepositoryFilterView::DoSearch(CRepositoryFilterView *self, std::_tstring searchText, std::_tstring searchModule, std::_tstring searchUser, DoSearchOptions searchOptions, std::_tstring dateTime)
{
CComPtr<IRepository> rep = AttachRepository();
IAttributeVectorPtr * results = new IAttributeVectorPtr(); //This is released in the submit done.
int foundCount = rep->FindAttributes(searchText, searchModule, searchUser, searchOptions.mode, searchOptions.sandboxed, searchOptions.checkedout, searchOptions.locked, searchOptions.orphaned, searchOptions.modifiedSince ? dateTime.c_str() : _T(""), *results);
::PostMessage(self->m_hWnd, CWM_SUBMITDONE, (WPARAM)(results), foundCount);
}
void Check(const std::_tstring & _url, const std::_tstring & _product)
{
clib::recursive_mutex::scoped_lock proc(m_mutex);
std::string url = CT2A(_url.c_str());
std::string product = CT2A(_product.c_str());
try
{
boost::asio::io_service io_service;
// Get a list of endpoints corresponding to the server name.
tcp::resolver resolver(io_service);
tcp::resolver::query query(url, "http");
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query);
tcp::resolver::iterator end;
// Try each endpoint until we successfully establish a connection.
tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end)
{
socket.close();
socket.connect(*endpoint_iterator++, error);
}
if (error)
throw boost::system::system_error(error);
// Form the request. We specify the "Connection: close" header so that the
// server will close the socket after transmitting the response. This will
// allow us to treat all data up until the EOF as the content.
boost::asio::streambuf request;
std::ostream request_stream(&request);
request_stream << "GET " << product << " HTTP/1.0\r\n";
request_stream << "Host: " << url << "\r\n";
request_stream << "Accept: */*\r\n";
request_stream << "Connection: close\r\n\r\n";
// Send the request.
boost::asio::write(socket, request);
// Read the response status line. The response streambuf will automatically
// grow to accommodate the entire line. The growth may be limited by passing
// a maximum size to the streambuf constructor.
boost::asio::streambuf response;
boost::asio::read_until(socket, response, "\r\n");
// Check that response is OK.
std::istream response_stream(&response);
std::string http_version;
response_stream >> http_version;
unsigned int status_code;
response_stream >> status_code;
std::string status_message;
std::getline(response_stream, status_message);
if (!response_stream || http_version.substr(0, 5) != "HTTP/")
{
m_error = "Invalid response";
return;
}
if (status_code != 200)
{
m_error = "Response returned with status code ";
try {
m_error += boost::lexical_cast<std::string>(status_code);
} catch (const boost::bad_lexical_cast &) {
m_error += "\n";
}
return;
}
// Read the response headers, which are terminated by a blank line.
boost::asio::read_until(socket, response, "\r\n\r\n");
// Process the response headers.
std::string header;
while (std::getline(response_stream, header) && header != "\r")
m_header + header + "\n";
std::stringstream m_responseStream;
// Write whatever content we already have to output.
if (response.size() > 0)
m_responseStream << &response;
// Read until EOF, writing data to output as we go.
while (boost::asio::read(socket, response, boost::asio::transfer_at_least(1), error))
m_responseStream << &response;
if (error != boost::asio::error::eof)
throw boost::system::system_error(error);
m_response = CA2T(m_responseStream.str().c_str());
boost::algorithm::trim_if(m_response, boost::algorithm::is_any_of(_T("\r\n")));
}
catch (const std::exception & ex)
{
m_error = ex.what();
}
return;
}
void Update(const std::_tstring & description)
{
if (!description.empty())
m_description = description;
}
