void Navigator::NavGroup(bool local)
{
for(int i = 0; i < nitem.GetCount(); i++) {
NavItem& m = nitem[i];
String g = m.nest;
if(m.kind == TYPEDEF)
g.Trim(max(g.ReverseFind("::"), 0));
if(IsNull(g) || CodeBase().namespaces.Find(m.nest) >= 0) {
if(g.GetCount()) // We want to show the namespace
g << '\xff';
else
g.Clear();
g << GetSourceFilePath(m.decl_file);
g = '\xff' + g;
}
if(!local)
g = (char)(m.pass + 10) + g;
if(local)
if(gitem.GetCount() && gitem.TopKey() == g)
gitem.Top().Add(&m);
else
gitem.Add(g).Add(&m);
else
gitem.GetAdd(g).Add(&m);
}
}
String ChangeTopicLanguage(const String &topic, int lang) {
int pos = topic.ReverseFind('$');
if (pos < 0)
return "";
String langtxt = ToLower(LNGAsText(lang));
return topic.Left(pos+1) + langtxt + topic.Mid(pos+1+langtxt.GetCount());
}
DateTime
Utilities::GetDateTimeFromReceivedHeader(const String &sReceivedHeader)
{
DateTime dtRetValue;
int iLastSemicolon = sReceivedHeader.ReverseFind(_T(";"));
if (iLastSemicolon == -1)
return dtRetValue;
String sDatePart = sReceivedHeader.Mid(iLastSemicolon + 1);
/*
sFirstPart now contains the following
received = "Received" ":" ; one per relay
["from" domain] ; sending host
["by" domain] ; receiving host
["via" atom] ; physical path
*("with" atom) ; link/mail protocol
["id" msg-id] ; receiver msg id
["for" addr-spec] ; initial form
";" date-time ; time received
http://cr.yp.to/immhf/envelope.html
In theory, the value of a Received field is tokenizable.
In practice, SMTP servers put all sorts of badly formatted information into Received lines.
Hence: We only do a quick search
*/
sDatePart.Trim();
dtRetValue = Time::GetDateTimeFromMimeHeader(sDatePart);
return dtRetValue;
}
String
Utilities::GetRecipientFromReceivedHeader(const String &sReceivedHeader)
{
int iLastSemicolon = sReceivedHeader.ReverseFind(_T(";"));
if (iLastSemicolon == -1)
return "";
String sFirstPart = sReceivedHeader.Mid(0, iLastSemicolon);
/*
sFirstPart now contains the following
received = "Received" ":" ; one per relay
["from" domain] ; sending host
["by" domain] ; receiving host
["via" atom] ; physical path
*("with" atom) ; link/mail protocol
["id" msg-id] ; receiver msg id
["for" addr-spec] ; initial form
";" date-time ; time received
http://cr.yp.to/immhf/envelope.html
In theory, the value of a Received field is tokenizable.
In practice, SMTP servers put all sorts of badly formatted information into Received lines.
Hence: We only do a quick search
*/
int iForPos = sFirstPart.ReverseFind(_T("for "));
if (iForPos == -1)
return "";
String sAddressPart = sFirstPart.Mid(iForPos + 4);
sAddressPart.TrimLeft(_T(" \r\n\t"));
sAddressPart.TrimRight(_T(" \r\n\t"));
sAddressPart.Replace(_T("<"), _T(""));
sAddressPart.Replace(_T(">"), _T(""));
sAddressPart.Replace(_T(" "), _T(""));
if (!StringParser::IsValidEmailAddress(sAddressPart))
return "";
return sAddressPart;
}
String
Utilities::GetExecutableDirectory()
{
String sPathIncExe = Application::GetExecutableName();
// Find last slash.
int iLastSlash = sPathIncExe.ReverseFind(_T("\\"));
return sPathIncExe.Mid(0, iLastSlash);
}
String
StringParser::ExtractDomain(const String &sEMailAddress)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Extracts the domain from an email address string. (the part after @)
//---------------------------------------------------------------------------()
{
int iAtSign = sEMailAddress.ReverseFind(_T("@"));
String sDomain = sEMailAddress.Mid(iAtSign+1);
return sDomain;
}
String
StringParser::ExtractAddress(const String &sEMailAddress)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Extracts the adress from an email address string. (the part before @)
//---------------------------------------------------------------------------()
{
int iAtSign = sEMailAddress.ReverseFind(_T("@"));
String sDomain = sEMailAddress.Mid(0, iAtSign);
return sDomain;
}
ArrayMap<String, EscValue> TemplateDlg::MakeVars0()
{
ArrayMap<String, EscValue> var;
String n = ~package;
int q = n.ReverseFind('/');
var.Add("PACKAGE", q >= 0 ? n.Mid(q + 1) : n);
var.Add("PACKAGE_TOUPPER", ToUpper(n));
var.Add("PACKAGE_TOUPPER_CAPS", ToUpper_Caps(n));
var.Add("DESCRIPTION", String(~description));
return var;
}
String
FileUtilities::GetFilePath(const String & FileName)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Returns the path to the folder in which FileName resides.
//---------------------------------------------------------------------------()
{
int iLastSlash = FileName.ReverseFind(_T("\\"));
String Path = FileName.Mid(0, iLastSlash);
return Path;
}
void
BackupExecuter::_RestoreDataDirectory(shared_ptr<Backup> pBackup, XNode *pBackupNode)
{
XNode *pBackupInfoNode = pBackupNode->GetChild(_T("BackupInformation"));
// Create the path to the zip file.
String sBackupFile = pBackup->GetBackupFile();
String sPath = sBackupFile.Mid(0, sBackupFile.ReverseFind(_T("\\")));
String sDirContainingDataFiles;
String sDataFileFormat = pBackupInfoNode->GetChildAttr(_T("DataFiles"), _T("Format"))->value;
String sExtractedFilesDirectory;
if (sDataFileFormat.CompareNoCase(_T("7Z")) == 0)
{
// Create the path to the directory that will contain the extracted files.
// This directory is temporary and will be removed when we're done.
sExtractedFilesDirectory = Utilities::GetUniqueTempDirectory();
// Extract the files to this directory.
Compression oComp;
oComp.Uncompress(sBackupFile, sExtractedFilesDirectory);
// The data files in the zip file are stored in
// a directory called DataBackup.
sDirContainingDataFiles = sExtractedFilesDirectory + "\\DataBackup";
}
else
{
// Fetch the path to the data files.
String sFolderName = pBackupInfoNode->GetChildAttr(_T("DataFiles"), _T("FolderName"))->value;
sDirContainingDataFiles = sPath + "\\" + sFolderName;
}
// Delete all directories from the data directory
// so that we're sure that we're doing a clean restore
String sDataDirectory = IniFileSettings::Instance()->GetDataDirectory();
std::set<String> vecExcludes;
FileUtilities::DeleteFilesInDirectory(sDataDirectory);
FileUtilities::DeleteDirectoriesInDirectory(sDataDirectory, vecExcludes);
String errorMessage;
FileUtilities::CopyDirectory(sDirContainingDataFiles, sDataDirectory, errorMessage);
if (sDataFileFormat.CompareNoCase(_T("7z")) == 0)
{
// The temporary directory we created while
// unzipping should be deleted now.
FileUtilities::DeleteDirectory(sExtractedFilesDirectory);
}
}
String
FileUtilities::GetFileNameFromFullPath(const String & sFullPath)
//---------------------------------------------------------------------------()
// DESCRIPTION:
// Returns the filename in the full path.
//---------------------------------------------------------------------------()
{
int iLastSlash = sFullPath.ReverseFind(_T("\\"));
if (iLastSlash == -1)
{
// Path is relative.
return sFullPath;
}
return sFullPath.Mid(iLastSlash + 1);
}
bool
FileUtilities::Copy(const String &sFrom, const String &sTo, bool bCreateMissingDirectories)
{
int iNumberOfTries = 0;
const int iMaxNumberOfTries = 5;
if (bCreateMissingDirectories)
{
String sToPath = sTo.Mid(0, sTo.ReverseFind(_T("\\")));
CreateDirectoryRecursive(sToPath);
}
const int maxRecursions = 10000;
for (int i = 0; i < maxRecursions; i++)
{
// Use classic api to copy the file
if (::CopyFile(sFrom, sTo, FALSE) != 0)
{
//Copy OK
return true;
}
iNumberOfTries ++;
// We failed to delete the file.
if (iNumberOfTries >= iMaxNumberOfTries)
{
// We still couldn't copy the file. Lets give up and report in windows event log and hMailServer application log
int iLastError = ::GetLastError();
String sErrorMessage;
sErrorMessage.Format(_T("Could not copy the file %s to %s. Tried 5 times without success. Windows eror code: %d (%s)"), sFrom, sTo, iLastError, Dictionary::GetWindowsErrorDescription(iLastError));
ErrorManager::Instance()->ReportError(ErrorManager::High, 5048, "File::Copy", sErrorMessage);
return false;
}
// Some other process must have locked the file.
Sleep(1000);
}
assert(0); // if we get here, something is really strange...
return false;
}
// POSIX lib files have names in form of libXXXXXX.so.ver.minver(.rel)
// so we can't simply get file extension
String CppBuilder::GetSrcType(String fn) const
{
fn = ToLower(fn);
String ext = GetFileExt(fn);
if(!HasFlag("POSIX") || ext == ".so")
return ext;
int soPos = fn.ReverseFind(".so");
if(soPos < 0)
return ext;
fn = fn.Mid(soPos + 3);
const char *c = ~fn;
while(*c)
{
if(*c != '.' && !IsDigit(*c))
return ext;
c++;
}
return ".so";
}
String CleanTp(const String& tp)
{
int q = tp.Find('<');
int w = tp.ReverseFind('>');
if(q < 0 || w < 0) return tp;
String a = TrimLeft(TrimRight(tp.Mid(q + 1, w - q - 1)));
const char *s = a;
String r;
while(*s) {
if(*s == ',') {
r.Cat(';');
s++;
while(*s == ' ')
s++;
}
else
r.Cat(*s++);
}
return r;
}
const wchar_t* PathHelper::GetModuleDir(HINSTANCE hInstance)
{
WCHAR szModulePath[MAX_PATH + 1];
::GetModuleFileName(hInstance, szModulePath, MAX_PATH);
String strPath = szModulePath;
int index = strPath.ReverseFind((const WCHAR*)L"\\");
if(index > 0)
{
strPath = strPath.Left(index + 1);
}
else
{
ASSERT(FALSE);
strPath += L"\\";
}
strPath.Replace((const WCHAR*)L"/",(const WCHAR*)L"\\");
return _wcsdup(strPath.GetData());
}
void TopicEditor::Hyperlink(String& link, WString& text)
{
TopicLinkDlg d;
d.link <<= link;
String label;
TopicLink tl;
int q = link.ReverseFind('#');
if(q >= 0) {
label = link.Mid(q + 1);
tl = ParseTopicLink(link.Mid(0, q));
}
else
tl = ParseTopicLink(link);
if(IsNull(tl.topic)) {
d.package.FindSetCursor(GetFileTitle(GetFileFolder(grouppath))) &&
d.group.FindSetCursor(GetFileTitle(grouppath)) &&
d.topic.FindSetCursor(topic.GetCurrentName());
}
else {
d.package.FindSetCursor(tl.package) &&
d.group.FindSetCursor(tl.group) &&
d.topic.FindSetCursor(tl.topic) &&
d.label.FindSetCursor(label);
}
int c = d.Run();
if(c == IDCANCEL)
return;
link = ~d.link;
if(c == IDOK)
return;
if(d.topic.IsCursor()) {
String fn = AppendFileName(d.PackageGroup(d.group.GetCurrentName()),
d.topic.GetCurrentName() + ".tpp");
text = ReadTopic(LoadFile(fn)).title.ToWString();
}
}
bool Qualify0(ScopeInfo& nf, const String& type, const String& usings, String& qt)
{ // Qualify single type based on scoping information
const Vector<String>& nd = nf.GetScopes(usings);
if(nd.GetCount()) {
LTIMING("First test");
qt = nd[0] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
if(nf.GetScope() >= 0) {
int q = type.ReverseFind(':');
if(q > 0) {
LTIMING("Qualifying qualification");
ScopeInfo hnf(nf);
hnf.NoBases();
String qn;
String qs = type.Mid(0, q - 1);
if(IsDigit(*qs)) {
qt = type;
return true;
}
if(DoQualify(hnf, qs, usings, qn)) {
String tp = type.Mid(q + 1);
if(nf.base.Find(qn) >= 0) {
qt = qn + "::" + tp;
return true;
}
int scopei = nf.base.Find(qn);
if(scopei >= 0) {
ScopeInfo nnf(nf.base, scopei);
const Vector<String>& bs = nnf.GetBases();
for(int i = 0; i < bs.GetCount(); i++) {
qt = bs[i] + tp;
if(nf.base.Find(qt) >= 0)
return true;
}
}
}
if(nf.base.Find(qs) >= 0) {
qt = qs;
return true;
}
qt = type;
if(nf.base.Find(qt) >= 0) // e.g. std::string
return true;
qt = type.Mid(q + 1);
return true;
}
else {
LTIMING("Bases");
const Vector<String>& bs = nf.GetBases();
for(int i = 0; i < bs.GetCount(); i++) {
qt = bs[i] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
}
}
if(type[0] != ':') {
LTIMING("Testing scopes");
for(int i = 1; i < nd.GetCount(); i++) {
qt = nd[i] + type;
if(nf.base.Find(qt) >= 0)
return true;
}
}
int q = type.Find(':');
if(q < 0)
return false;
return Qualify0(nf, type.Mid(q + 1), usings, qt);
}
String GetTopicLanguage(const String &topic) {
int pos = topic.ReverseFind('$');
if (pos < 0)
return "";
return topic.Mid(pos+1, 5);
}
