void init()
{
helper = (IHThorKeyDiffArg *)queryHelper();
OwnedRoxieString origName(helper->getOriginalName());
OwnedRoxieString updatedName(helper->getUpdatedName());
originalIndexFile.setown(queryThorFileManager().lookup(container.queryJob(), origName));
newIndexFile.setown(queryThorFileManager().lookup(container.queryJob(), updatedName));
if (originalIndexFile->numParts() != newIndexFile->numParts())
throw MakeActivityException(this, TE_KeyDiffIndexSizeMismatch, "Index %s and %s differ in width", origName.get(), updatedName.get());
if (originalIndexFile->querySuperFile() || newIndexFile->querySuperFile())
throw MakeActivityException(this, 0, "Diffing super files not supported");
width = originalIndexFile->numParts();
originalDesc.setown(originalIndexFile->getFileDescriptor());
newIndexDesc.setown(newIndexFile->getFileDescriptor());
Owned<IPartDescriptor> tlkDesc = originalDesc->getPart(originalDesc->numParts()-1);
const char *kind = tlkDesc->queryProperties().queryProp("@kind");
local = NULL == kind || 0 != stricmp("topLevelKey", kind);
if (!local)
width--; // 1 part == No n distributed / Monolithic key
if (width > container.queryJob().querySlaves())
throw MakeActivityException(this, 0, "Unsupported: keydiff(%s, %s) - Cannot diff a key that's wider(%d) than the target cluster size(%d)", originalIndexFile->queryLogicalName(), newIndexFile->queryLogicalName(), width, container.queryJob().querySlaves());
queryThorFileManager().noteFileRead(container.queryJob(), originalIndexFile);
queryThorFileManager().noteFileRead(container.queryJob(), newIndexFile);
IArrayOf<IGroup> groups;
OwnedRoxieString outputName(helper->getOutputName());
fillClusterArray(container.queryJob(), outputName, clusters, groups);
patchDesc.setown(queryThorFileManager().create(container.queryJob(), outputName, clusters, groups, 0 != (KDPoverwrite & helper->getFlags()), 0, !local, width));
}
void RestoreFrame::OnBrowseButtonClick(wxCommandEvent& WXUNUSED(event))
{
wxFileName origName(text_ctrl_filename->GetValue());
wxString filename = ::wxFileSelector(_("Select Backup File"),
origName.GetPath(), origName.GetFullName(), "*.fbk",
_("Backup file (*.fbk, *.gbk)|*.fbk;*.gbk|All files (*.*)|*.*"),
wxFD_OPEN, this);
if (!filename.empty())
text_ctrl_filename->SetValue(filename);
}
Note
NotationStrings::getNoteForName(QString name)
{
std::string origName(qstrtostr(name));
int pos = name.indexOf('-');
int dots = 0;
if (pos > 0 && pos < 6 && pos < name.length() - 1) {
dots = name.left(pos).toInt();
name = name.right(name.length() - pos - 1);
if (dots < 2) {
throw MalformedNoteName("Non-numeric or invalid dot count in \"" +
origName + "\"");
}
}
if (name.length() > 7 &&
(name.left(7) == "dotted " || name.left(7) == "dotted-")) {
if (dots == 0)
dots = 1;
name = name.right(name.length() - 7);
} else {
if (dots > 1) {
throw MalformedNoteName("Dot count without dotted tag in \"" +
origName + "\"");
}
}
if (name.length() > 5 && name.right(5) == " note") {
name = name.left(name.length() - 5);
}
Note::Type type;
static const char *names[][4] = {
{ "64th", "sixty-fourth", "hemidemisemi", "hemidemisemiquaver" },
{ "32nd", "thirty-second", "demisemi", "demisemiquaver" },
{ "16th", "sixteenth", "semi", "semiquaver" },
{ "8th", "eighth", 0, "quaver" },
{ "quarter", 0, 0, "crotchet", },
{ "half", 0, 0, "minim" },
{ "whole", 0, 0, "semibreve" },
{ "double whole", 0, 0, "breve" }
};
for (type = Note::Shortest; type <= Note::Longest; ++type) {
for (int i = 0; i < 4; ++i) {
if (!names[type][i]) continue;
if (name == names[type][i]) return Note(type, dots);
}
}
throw MalformedNoteName("Can't parse note name \"" + origName + "\"");
}
CArchiveDir::CArchiveDir(const std::string& archivename) :
CArchiveBase(archivename),
archiveName(archivename + '/')
{
std::vector<std::string> found = filesystem.FindFiles(archiveName, "*", FileSystem::RECURSE);
// because spring expects the contents of archives to be case independent,
// we convert filenames to lowercase in every function, and keep a std::map
// lcNameToOrigName to convert back from lowercase to original case.
for (std::vector<std::string>::iterator it = found.begin(); it != found.end(); ++it) {
// strip our own name off.. & convert to forward slashes
std::string origName(*it, archiveName.length());
filesystem.ForwardSlashes(origName);
// convert to lowercase and store
searchFiles.push_back(origName);
lcNameIndex[StringToLower(origName)] = searchFiles.size()-1;
}
}
void Operator<Node>::paramsToUpper(Teuchos::ParameterList &plist, int &changed, bool rmUnderscore)
{
changed = 0;
// get a list of all parameter names in the list
std::vector<std::string> paramNames ;
Teuchos::ParameterList::ConstIterator pIter;
pIter = plist.begin();
while (1){
//////////////////////////////////////////////////////////////////////
// Compiler considered this while statement an error
// for ( pIter = plist.begin() ; pIter != plist.end() ; pIter++ ){
// }
//////////////////////////////////////////////////////////////////////
if (pIter == plist.end()) break;
const std::string & nm = plist.name(pIter);
paramNames.push_back(nm);
pIter++;
}
// Change parameter names and values to upper case
for (unsigned int i=0; i < paramNames.size(); i++){
std::string origName(paramNames[i]);
int paramNameChanged = 0;
stringToUpper(paramNames[i], paramNameChanged, rmUnderscore);
if (plist.isSublist(origName)){
Teuchos::ParameterList &sublist = plist.sublist(origName);
int sublistChanged=0;
paramsToUpper(sublist, sublistChanged, false);
if (paramNameChanged){
// this didn't work, so I need to remove the old sublist
// and create a new one
//
//sublist.setName(paramNames[i]);
Teuchos::ParameterList newlist(sublist);
plist.remove(origName);
plist.set(paramNames[i], newlist);
}
}
else if (plist.isParameter(origName)){
std::string paramVal(plist.get<std::string>(origName));
int paramValChanged=0;
stringToUpper(paramVal, paramValChanged);
if (paramNameChanged || paramValChanged){
if (paramNameChanged){
plist.remove(origName);
}
plist.set(paramNames[i], paramVal);
changed++;
}
}
} // next parameter or sublist
}