|
|
// Active Directory Display Specifier Upgrade Tool
//
// Copyright (c) 2001 Microsoft Corporation
//
// class Repairer
//
// keeps a list of the localeIds to be extracted from the dcpromo.csv file,
// and a list of operations to be represented in an LDIF file.
//
// 7 Mar 2001 sburns
#include "headers.hxx"
#include "Repairer.hpp"
// // // make sure that the ldif operations are executed in advance of the csv
// // // operations. this is so the object creates will not conflict with object
// // // deletes
Repairer::Repairer( const String& dcpromoCsvFilePath_) : dcpromoCsvFilePath(dcpromoCsvFilePath_){ LOG_CTOR(Repairer); ASSERT(!dcpromoCsvFilePath.empty());
}
boolRepairer::IsLocaleInObjectsToCreateTable(int localeId) const{ LOG_FUNCTION2( Repairer::IsLocaleInObjectsToCreateTable, String::format(L"%1!d!", localeId)); ASSERT(localeId);
bool result = false;
for ( LocaleIdObjectNamePairList::iterator i = objectsToCreate.begin(); i != objectsToCreate.end(); ++i) { if (i->first == localeId) { result = true; break; } }
LOG_BOOL(result);
return result;}
voidRepairer::AddCreateContainerWorkItem(int localeId){ LOG_FUNCTION2( Repairer::AddCreateContainerWorkItem, String::format(L"%1!d!", localeId)); ASSERT(localeId);
do { LocaleIdList::iterator i = std::find( containersToCreate.begin(), containersToCreate.end(), localeId);
if (i != containersToCreate.end()) { // The locale should not already be in the list, since each locale
// container is evaluated only once.
LOG(L"locale already in list"); ASSERT(false); break; } if (IsLocaleInObjectsToCreateTable(localeId)) { // We don't expect any entries for this locale to be present in the
// objects-to-create list, because the containers are evaluated first.
LOG(L"objects for locale already in object list"); ASSERT(false);
// CODEWORK: we should handle this situation anyway, just for
// robustness' sake. To deal with it, all entires in the objects-
// to-create list for this locale id should be removed.
break; }
containersToCreate.push_back(localeId); } while (0);}
voidRepairer::AddCreateObjectWorkItem( int localeId, const String& displaySpecifierObjectName){ LOG_FUNCTION2( Repairer::AddCreateObjectWorkItem, String::format( L"%1!d! %2", localeId, displaySpecifierObjectName.c_str())); ASSERT(localeId); ASSERT(!displaySpecifierObjectName.empty()); do { LocaleIdList::iterator i = std::find( containersToCreate.begin(), containersToCreate.end(), localeId);
if (i != containersToCreate.end()) { // The locale is already in the containers-to-create list, which
// we don't expect, since if the container does not exist, we should
// not be evaluating which objects should be created in that container.
ASSERT(false);
// do nothing, as the object will be created as part of the container
// creation.
break; }
LocaleIdObjectNamePair p(localeId, displaySpecifierObjectName); LocaleIdObjectNamePairList::iterator j = std::find( objectsToCreate.begin(), objectsToCreate.end(), p); if (j != objectsToCreate.end()) { // The object is already in the list. We don't expect this, since
// each object should be evaluated only once per locale.
ASSERT(false);
// do nothing, if the object is already present, then fine.
break; }
objectsToCreate.push_back(p); } while (0);}
voidRepairer::AddDeleteObjectWorkItem( int localeId, const String& displaySpecifierObjectName){ //CODEWORK:
//lucios: Inserted to remove link error
localeId++; String x=displaySpecifierObjectName;}
HRESULT Repairer::BuildRepairFiles(){ LOG_FUNCTION(Repairer::BuildRepairFiles);
HRESULT hr = S_OK; // CODEWORK
// csv file:
//
// create a (temp) file
// copy out the first line of the dcpromo.csv file (the column labels)
// for each localeid in the list
// copy out all of the lines in the dcpromo.csv file for that locale
// for each <localeid, objectname> entry
// copy out that line from the dcpromo.csv file
//
// ldif file:
LOG_HRESULT(hr); return hr;}
HRESULTRepairer::ApplyRepairs(){ LOG_FUNCTION(Repairer::ApplyRepairs);
HRESULT hr = S_OK;
// CODEWORK: needs finishing
LOG_HRESULT(hr);
return hr;}
// could have gone with a architecture like:
//
// repairer.workQueue.Add(new CreateContainerWorkItem(localeId));
//
// but while that certainly seems more OO, more "extensible" because new work
// item types could be derived. Upon further thought, it seems like a worse
// solution to me, since there are them lots of trivial classes involved, and
// the coordination of those classes becomes a real nuisance. Once all the
// work items are collected, who's responsible for translating them into the
// csv/ldif files? It would have to be an additional manager class. The
// extensibility turns out to be an illusion, since adding a new work item
// type requires modifying the manager class. So the added complexity buys
// nothing.
//
// The other design choice was whether to make the Repairer a "static class"
// -- my name for a class that is really a namespace, which instead of members
// uses static data that is hidden in a single translation unit as though it
// were private class data. This is a technique that makes the private data
// truly secret, as there is no mention of the data in the header declaration
// for the class at all. It also is a nice way to implement the Singleton
// pattern: there are no instances, and therefore no need to worry about
// constructors, destructors, assignment, stack or heap allocation, no
// "GetInstance" methods, and no lifetime issues.
//
// The technique gives a slightly nicer syntax as:
//
// Repairer::AddCreateContainerWorkItem(localeId)
//
// as opposed to
//
// Repairer::GetInstance()->AddCreateContainerWorkItem(localeId);
//
// I decided to go with a real, fully-contained object implementation, instead
// of a singleton, thinking that maybe someday multiple instances could be
// repairing multiple forests at once. Not likely, but why not?
|
