SettingDependencyMap CSettingsManager::GetDependencies(const CSetting *setting) const
{
if (setting == NULL)
return SettingDependencyMap();
return GetDependencies(setting->GetId());
}
void CSettingsManager::OnSettingChanged(const CSetting *setting)
{
CSharedLock lock(m_settingsCritical);
if (!m_loaded || setting == NULL)
return;
SettingMap::const_iterator settingIt = m_settings.find(setting->GetId());
if (settingIt == m_settings.end())
return;
Setting settingData = settingIt->second;
// now that we have a copy of the setting's data, we can leave the lock
lock.Leave();
for (CallbackSet::iterator callback = settingData.callbacks.begin();
callback != settingData.callbacks.end();
++callback)
(*callback)->OnSettingChanged(setting);
// now handle any settings which depend on the changed setting
const SettingDependencyMap& deps = GetDependencies(setting);
for (SettingDependencyMap::const_iterator depsIt = deps.begin(); depsIt != deps.end(); ++depsIt)
{
for (SettingDependencies::const_iterator depIt = depsIt->second.begin(); depIt != depsIt->second.end(); ++depIt)
UpdateSettingByDependency(depsIt->first, *depIt);
}
}
c4_Notifier *c4_DerivedSeq::PreChange(c4_Notifier &nf_) {
if (!GetDependencies())
return 0;
c4_Notifier *chg = d4_new c4_Notifier(this);
switch (nf_._type) {
case c4_Notifier::kSetAt: chg->StartSetAt(nf_._index, *nf_._cursor);
break;
case c4_Notifier::kSet: chg->StartSet(nf_._index, nf_._propId, *nf_._bytes)
;
break;
case c4_Notifier::kInsertAt: chg->StartInsertAt(nf_._index, *nf_._cursor,
nf_._count);
break;
case c4_Notifier::kRemoveAt: chg->StartRemoveAt(nf_._index, nf_._count);
break;
case c4_Notifier::kMove: chg->StartMove(nf_._index, nf_._count);
break;
}
return chg;
}
wxArrayString Project::GetDependencies(const wxString& configuration) const
{
wxArrayString result;
// dependencies are located directly under the root level
wxXmlNode *node = m_doc.GetRoot()->GetChildren();
while (node) {
if ( node->GetName() == wxT("Dependencies") && node->GetPropVal(wxT("Name"), wxEmptyString) == configuration) {
// we have our match
wxXmlNode *child = node->GetChildren();
while (child) {
if (child->GetName() == wxT("Project")) {
result.Add(XmlUtils::ReadString(child, wxT("Name")));
}
child = child->GetNext();
}
return result;
}
node = node->GetNext();
}
// if we are here, it means no match for the given configuration
// return the default dependencies
return GetDependencies();
}
/// Insert one or more rows into this sequence
void c4_Sequence::InsertAt(int index_, c4_Cursor newElem_, int count_)
{
d4_assert(newElem_._seq != 0);
c4_Notifier change(this);
if (GetDependencies()) {
change.StartInsertAt(index_, newElem_, count_);
}
SetNumRows(NumRows() + count_);
c4_Bytes data;
for (int i = 0; i < newElem_._seq->NumHandlers(); ++i) {
c4_Handler &h = newElem_._seq->NthHandler(i);
// added 06-12-1999 to do index remapping for derived seq's
const c4_Sequence *hc = newElem_._seq->HandlerContext(i);
int ri = newElem_._seq->RemapIndex(newElem_._index, hc);
int colNum = PropIndex(h.Property());
d4_assert(colNum >= 0);
if (h.Property().Type() == 'V') {
// If inserting from self: Make sure we get a copy of the bytes,
// so we don't get an invalid pointer if the memory get realloc'ed
h.GetBytes(ri, data, newElem_._seq == this);
// special treatment for subviews, insert empty, then overwrite
// changed 19990904 - probably fixes a long-standing limitation
c4_Bytes temp;
h.ClearBytes(temp);
c4_Handler &h2 = NthHandler(colNum);
h2.Insert(index_, temp, count_);
for (int j = 0; j < count_; ++j) {
h2.Set(index_ + j, data);
}
} else {
h.GetBytes(ri, data);
NthHandler(colNum).Insert(index_, data, count_);
}
}
// if number of props in dest is larger after adding, clear the rest
// this way, new props get copied and undefined props get cleared
if (newElem_._seq->NumHandlers() < NumHandlers()) {
for (int j = 0; j < NumHandlers(); ++j) {
c4_Handler &h = NthHandler(j);
// if the property does not appear in the source
if (newElem_._seq->PropIndex(h.PropId()) < 0) {
h.ClearBytes(data);
h.Insert(index_, data, count_);
}
}
}
}
SettingDependencyMap CSettingsManager::GetDependencies(const CSetting *setting) const
{
CSingleLock lock(m_critical);
if (setting == NULL)
return SettingDependencyMap();
return GetDependencies(setting->GetId());
}
/// Move a row to another position
void c4_Sequence::Move(int from_, int to_) {
c4_Notifier change(this);
if (GetDependencies())
change.StartMove(from_, to_);
//! careful, this does no index remapping, wrong for derived seq's
for (int i = 0; i < NumHandlers(); ++i)
NthHandler(i).Move(from_, to_);
}
/// Remove one or more rows from this sequence
void c4_Sequence::RemoveAt(int index_, int count_) {
c4_Notifier change(this);
if (GetDependencies())
change.StartRemoveAt(index_, count_);
SetNumRows(NumRows() - count_);
//! careful, this does no index remapping, wrong for derived seq's
for (int i = 0; i < NumHandlers(); ++i)
NthHandler(i).Remove(index_, count_);
}
//--------------------------------------------------------------------------------
BOOL CNTService::InstallService()
{
AFX_MANAGE_STATE_IF_DLL
TCHAR szPath[1024];
if(GetModuleFileName( 0, szPath, 1023 ) == 0 )
return FALSE;
BOOL bRet = FALSE;
SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if(schSCManager != NULL)
{
DWORD nServiceType = GetServiceType();
DWORD nStartType = GetStartType();
SC_HANDLE schService = CreateService(
schSCManager,
GetServiceName(),
GetDisplayName(),
GetDesiredAccess(),
nServiceType,
nStartType,
GetErrorControl(),
szPath,
GetLoadOrderGroup(),
((nServiceType == SERVICE_KERNEL_DRIVER ||
nServiceType == SERVICE_FILE_SYSTEM_DRIVER) &&
(nStartType == SERVICE_BOOT_START ||
nStartType == SERVICE_SYSTEM_START)) ?
&m_dwTagID : NULL,
GetDependencies(),
GetUserName(),
GetPassword()
);
if(schService != NULL)
{
CloseServiceHandle(schService);
bRet = TRUE;
}
CloseServiceHandle(schSCManager);
}
if(bRet)
// installation succeeded. Now register the message file
RegisterApplicationLog(szPath, EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE);
return bRet;
}
TEST ( DependencyMap, DependencyMapStringConstruct )
{
std::vector<size_t> result{2, 4, 5, 3, 1, 7, 9, 8, 6};
DependencyMap<std::string, size_t> dependency_map
{
{
"six", {"seven"}, 6
},
{
"one", {"two", "three"}, 1
},
{
"three", {"four", "five"}, 3
},
{
"five", {"four"}, 5
},
{
"nine", {"seven"}, 9
},
{
"two", {}, 2
},
{
"four", {}, 4
},
{
"seven", {"one", "two", "three", "four", "five"}, 7
},
{
"eight", {"nine"}, 8
}
};
ASSERT_EQ ( result.size(), dependency_map.Size() );
for ( auto i = dependency_map.begin(); i != dependency_map.end(); ++i )
{
for ( auto& j : i.GetDependencies() )
{
bool dependency_stored_before{false};
for ( auto k = dependency_map.begin(); k != i; ++k )
{
if ( k.GetKey() == j )
{
dependency_stored_before = true;
break;
}
}
EXPECT_TRUE ( dependency_stored_before );
}
}
}
// Get and display the list of Windows Cluster resources.
void WcDependencies::SetList(void)
{
LV_ITEM lvitem;
int index;
CRect rect;
CString strName, strType;
strName.LoadString(IDS_RESOURCENAME);
strType.LoadString(IDS_RESOURCETYPE);
m_ResourceListCtrl.GetClientRect(&rect);
m_ResourceListCtrl.InsertColumn(0, strName, LVCFMT_LEFT,
rect.Width() * 1/2, 0);
m_ResourceListCtrl.InsertColumn(1, strType, LVCFMT_LEFT,
rect.Width() * 1/2, 1);
for(int i=0; i<thePreSetup.m_ClusterResources.GetSize(); i++)
{
WcClusterResource *resource=(WcClusterResource *) thePreSetup.m_ClusterResources.GetAt(i);
if(resource &&
resource->m_name != thePreSetup.m_ResourceName)
{
lvitem.mask=LVIF_TEXT;
lvitem.iItem=i;
lvitem.iSubItem=0;
lvitem.pszText=resource->m_name.GetBuffer();
index = m_ResourceListCtrl.InsertItem(&lvitem);
lvitem.mask=LVIF_TEXT;
lvitem.iItem=index;
lvitem.iSubItem=1;
lvitem.pszText=resource->m_type.GetBuffer();
m_ResourceListCtrl.SetItem(&lvitem);
}
}
// Also insert the columns of the dependency list.
m_DependencyListCtrl.GetClientRect(&rect);
m_DependencyListCtrl.InsertColumn(0, strName, LVCFMT_LEFT,
rect.Width() * 1/2, 0);
m_DependencyListCtrl.InsertColumn(1, strType, LVCFMT_LEFT,
rect.Width() * 1/2, 1);
GetDependencies();
}
/// Replace the contents of a specified row
void c4_Sequence::SetAt(int index_, c4_Cursor newElem_)
{
d4_assert(newElem_._seq != 0);
c4_Bytes data;
c4_Notifier change(this);
if(GetDependencies())
change.StartSetAt(index_, newElem_);
for(int i = 0; i < newElem_._seq->NumHandlers(); ++i)
{
c4_Handler &h = newElem_._seq->NthHandler(i);
// added 06-12-1999 to do index remapping for derived seq's
const c4_Sequence *hc = newElem_._seq->HandlerContext(i);
int ri = newElem_._seq->RemapIndex(newElem_._index, hc);
h.GetBytes(ri, data);
// Set(index_, cursor._seq->NthProperty(i), data);
int colNum = PropIndex(h.Property());
d4_assert(colNum >= 0);
NthHandler(colNum).Set(index_, data);
}
// if number of props in dest is larger after adding, clear the rest
// this way, new props get copied and undefined props get cleared
if(newElem_._seq->NumHandlers() < NumHandlers())
{
for(int j = 0; j < NumHandlers(); ++j)
{
c4_Handler &h = NthHandler(j);
// if the property does not appear in the source
if(newElem_._seq->PropIndex(h.PropId()) < 0)
{
h.ClearBytes(data);
h.Set(index_, data);
}
}
}
}
bool
SourceFileC::CheckNeedsBuild(BuildInfo &info, bool check_deps)
{
// The checks for a file needing to be built:
// 1) Build flag != BUILD_MAYBE => return result
// 2) Object file missing
// 3) Source mod time > object mod time
// 4) Dependency file needs build
// The fast stuff
if (!info.objectFolder.GetFullPath())
{
STRACE(2,("CheckNeedsBuild: empty file path\n"));
return false;
}
if (BuildFlag() == BUILD_YES)
{
STRACE(2,("%s::CheckNeedsBuild: build flag == YES\n",GetPath().GetFullPath()));
return true;
}
// Object file existence
BString objname(GetPath().GetBaseName());
objname << ".o";
DPath objpath(info.objectFolder);
objpath.Append(objname);
if (!BEntry(objpath.GetFullPath()).Exists())
{
STRACE(2,("%s::CheckNeedsBuild: object doesn't exist\n",GetPath().GetFullPath()));
return true;
}
// source vs object mod time
struct stat objstat;
if (GetStat(objpath.GetFullPath(),&objstat) != B_OK)
{
STRACE(2,("%s::CheckNeedsBuild: couldn't stat object\n",GetPath().GetFullPath()));
return false;
}
// Fix mod times set into the future
time_t now = real_time_clock();
if (GetModTime() > now)
{
BNode node(GetPath().GetFullPath());
node.SetModificationTime(now);
}
if (GetModTime() > objstat.st_mtime)
{
STRACE(2,("%s::CheckNeedsBuild: file time more recent than object time\n",
GetPath().GetFullPath()));
return true;
}
if (!check_deps)
{
STRACE(2,("%s::CheckNeedsBuild: dependency checking disabled for call\n",
GetPath().GetFullPath()));
return false;
}
// Dependency check
BString str(GetDependencies());
if (str.CountChars() < 1)
{
STRACE(2,("%s::CheckNeedsBuild: initial dependency update\n",
GetPath().GetFullPath()));
UpdateDependencies(info);
str = GetDependencies();
}
if (str.CountChars() > 0)
{
char *pathstr;
char depString[str.Length() + 1];
sprintf(depString,"%s",str.String());
pathstr = strtok(depString,"|");
while (pathstr)
{
BString filename(DPath(pathstr).GetFileName());
if (filename.Compare(GetPath().GetFileName()) != 0)
{
DPath depPath(FindDependency(info,filename.String()));
if (!depPath.IsEmpty())
{
struct stat depstat;
if (GetStat(depPath.GetFullPath(),&depstat) == B_OK &&
depstat.st_mtime > objstat.st_mtime)
{
STRACE(2,("%s::CheckNeedsBuild: dependency %s was updated\n",
GetPath().GetFullPath(),depPath.GetFullPath()));
return true;
}
}
}
pathstr = strtok(NULL,"|");
}
}
return false;
}
