void
JEPSPrinter::ReadEPSSetup
(
istream& input
)
{
JFileVersion vers;
input >> vers;
if (vers <= kCurrentSetupVersion)
{
JString fileName;
JBoolean bwFlag;
input >> fileName >> itsIncludePreviewFlag >> bwFlag;
SetOutputFileName(fileName);
PSPrintBlackWhite(bwFlag);
}
void DoMuscle()
{
SetOutputFileName(g_pstrOutFileName.get());
SetInputFileName(g_pstrInFileName.get());
SetMaxIters(g_uMaxIters.get());
SetSeqWeightMethod(g_SeqWeight1.get());
TextFile fileIn(g_pstrInFileName.get());
SeqVect v;
v.FromFASTAFile(fileIn);
const unsigned uSeqCount = v.Length();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType.get())
{
case SEQTYPE_Auto:
Alpha = v.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid seq type");
}
SetAlpha(Alpha);
v.FixAlpha();
//
// AED 21/12/06: Moved matrix loading code inside the PP param function so it gets called for all alignment types
//
SetPPScore();
unsigned uMaxL = 0;
unsigned uTotL = 0;
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
unsigned L = v.GetSeq(uSeqIndex).Length();
uTotL += L;
if (L > uMaxL)
uMaxL = L;
}
SetIter(1);
g_bDiags.get() = g_bDiags1.get();
SetSeqStats(uSeqCount, uMaxL, uTotL/uSeqCount);
SetMuscleSeqVect(v);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
v.SetSeqId(uSeqIndex, uSeqIndex);
if (0 == uSeqCount)
Quit("Input file '%s' has no sequences", g_pstrInFileName.get());
if (1 == uSeqCount)
{
TextFile fileOut(g_pstrOutFileName.get(), true);
v.ToFile(fileOut);
return;
}
if (uSeqCount > 1)
MHackStart(v);
// First iteration
Tree GuideTree;
if (0 != g_pstrUseTreeFileName.get())
{
// Discourage users...
if (!g_bUseTreeNoWarn.get())
fprintf(stderr, g_strUseTreeWarning);
// Read tree from file
TextFile TreeFile(g_pstrUseTreeFileName.get());
GuideTree.FromFile(TreeFile);
// Make sure tree is rooted
if (!GuideTree.IsRooted())
Quit("User tree must be rooted");
if (GuideTree.GetLeafCount() != uSeqCount)
Quit("User tree does not match input sequences");
const unsigned uNodeCount = GuideTree.GetNodeCount();
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (!GuideTree.IsLeaf(uNodeIndex))
continue;
const char *LeafName = GuideTree.GetLeafName(uNodeIndex);
unsigned uSeqIndex;
bool SeqFound = v.FindName(LeafName, &uSeqIndex);
if (!SeqFound)
Quit("Label %s in tree does not match sequences", LeafName);
unsigned uId = v.GetSeqIdFromName(LeafName);
GuideTree.SetLeafId(uNodeIndex, uId);
}
}
else
TreeFromSeqVect(v, GuideTree, g_Cluster1.get(), g_Distance1.get(), g_Root1.get(),
g_pstrDistMxFileName1.get());
const char *Tree1 = ValueOpt("Tree1");
if (0 != Tree1)
{
TextFile f(Tree1, true);
GuideTree.ToFile(f);
if (g_bClusterOnly.get())
return;
}
SetMuscleTree(GuideTree);
ValidateMuscleIds(GuideTree);
MSA msa;
ProgNode *ProgNodes = 0;
if (g_bLow.get())
ProgNodes = ProgressiveAlignE(v, GuideTree, msa);
else
ProgressiveAlign(v, GuideTree, msa);
SetCurrentAlignment(msa);
if (0 != g_pstrComputeWeightsFileName.get())
{
extern void OutWeights(const char *FileName, const MSA &msa);
SetMSAWeightsMuscle(msa);
OutWeights(g_pstrComputeWeightsFileName.get(), msa);
return;
}
ValidateMuscleIds(msa);
if (1 == g_uMaxIters.get() || 2 == uSeqCount)
{
//TextFile fileOut(g_pstrOutFileName.get(), true);
//MHackEnd(msa);
//msa.ToFile(fileOut);
MuscleOutput(msa);
return;
}
if (0 == g_pstrUseTreeFileName.get())
{
g_bDiags.get() = g_bDiags2.get();
SetIter(2);
if (g_bLow.get())
{
if (0 != g_uMaxTreeRefineIters.get())
RefineTreeE(msa, v, GuideTree, ProgNodes);
}
else
RefineTree(msa, GuideTree);
const char *Tree2 = ValueOpt("Tree2");
if (0 != Tree2)
{
TextFile f(Tree2, true);
GuideTree.ToFile(f);
}
}
SetSeqWeightMethod(g_SeqWeight2.get());
SetMuscleTree(GuideTree);
if (g_bAnchors.get())
RefineVert(msa, GuideTree, g_uMaxIters.get() - 2);
else
RefineHoriz(msa, GuideTree, g_uMaxIters.get() - 2, false, false);
#if 0
// Refining by subfamilies is disabled as it didn't give better
// results. I tried doing this before and after RefineHoriz.
// Should get back to this as it seems like this should work.
RefineSubfams(msa, GuideTree, g_uMaxIters.get() - 2);
#endif
ValidateMuscleIds(msa);
ValidateMuscleIds(GuideTree);
//TextFile fileOut(g_pstrOutFileName.get(), true);
//MHackEnd(msa);
//msa.ToFile(fileOut);
MuscleOutput(msa);
}
void DoMuscle(CompositeVect*CVLocation)
{
SetOutputFileName(g_pstrOutFileName);
SetInputFileName(g_pstrInFileName);
SetMaxIters(g_uMaxIters);
SetSeqWeightMethod(g_SeqWeight1);
TextFile fileIn(g_pstrInFileName);
SeqVect v;
v.FromFASTAFile(fileIn);
const unsigned uSeqCount = v.Length();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType)
{
case SEQTYPE_Auto:
Alpha = v.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid seq type");
}
SetAlpha(Alpha);
v.FixAlpha();
PTR_SCOREMATRIX UserMatrix = 0;
if (0 != g_pstrMatrixFileName)
{
const char *FileName = g_pstrMatrixFileName;
const char *Path = getenv("MUSCLE_MXPATH");
if (Path != 0)
{
size_t n = strlen(Path) + 1 + strlen(FileName) + 1;
char *NewFileName = new char[n];
sprintf(NewFileName, "%s/%s", Path, FileName);
FileName = NewFileName;
}
TextFile File(FileName);
UserMatrix = ReadMx(File);
g_Alpha = ALPHA_Amino;
g_PPScore = PPSCORE_SP;
}
SetPPScore();
if (0 != UserMatrix)
g_ptrScoreMatrix = UserMatrix;
unsigned uMaxL = 0;
unsigned uTotL = 0;
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
unsigned L = v.GetSeq(uSeqIndex).Length();
uTotL += L;
if (L > uMaxL)
uMaxL = L;
}
SetIter(1);
g_bDiags = g_bDiags1;
SetSeqStats(uSeqCount, uMaxL, uTotL/uSeqCount);
SetMuscleSeqVect(v);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
v.SetSeqId(uSeqIndex, uSeqIndex);
if (0 == uSeqCount)
Quit("Input file '%s' has no sequences", g_pstrInFileName);
if (1 == uSeqCount)
{
TextFile fileOut(g_pstrOutFileName, true);
v.ToFile(fileOut);
return;
}
if (uSeqCount > 1)
MHackStart(v);
// First iteration
Tree GuideTree;
if (0 != g_pstrUseTreeFileName)
{
// Discourage users...
if (!g_bUseTreeNoWarn)
fprintf(stderr, "%s", g_strUseTreeWarning);
// Read tree from file
TextFile TreeFile(g_pstrUseTreeFileName);
GuideTree.FromFile(TreeFile);
// Make sure tree is rooted
if (!GuideTree.IsRooted())
Quit("User tree must be rooted");
if (GuideTree.GetLeafCount() != uSeqCount)
Quit("User tree does not match input sequences");
const unsigned uNodeCount = GuideTree.GetNodeCount();
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (!GuideTree.IsLeaf(uNodeIndex))
continue;
const char *LeafName = GuideTree.GetLeafName(uNodeIndex);
unsigned uSeqIndex;
bool SeqFound = v.FindName(LeafName, &uSeqIndex);
if (!SeqFound)
Quit("Label %s in tree does not match sequences", LeafName);
unsigned uId = v.GetSeqIdFromName(LeafName);
GuideTree.SetLeafId(uNodeIndex, uId);
}
}
else
TreeFromSeqVect(v, GuideTree, g_Cluster1, g_Distance1, g_Root1,
g_pstrDistMxFileName1);
const char *Tree1 = ValueOpt("Tree1");
if (0 != Tree1)
{
TextFile f(Tree1, true);
GuideTree.ToFile(f);
if (g_bClusterOnly)
return;
}
SetMuscleTree(GuideTree);
ValidateMuscleIds(GuideTree);
MSA msa;
msa.SetCompositeVector(CVLocation);
ProgNode *ProgNodes = 0;
if (g_bLow)
ProgNodes = ProgressiveAlignE(v, GuideTree, msa);
else
ProgressiveAlign(v, GuideTree, msa);
SetCurrentAlignment(msa);
if (0 != g_pstrComputeWeightsFileName)
{
extern void OutWeights(const char *FileName, const MSA &msa);
SetMSAWeightsMuscle(msa);
OutWeights(g_pstrComputeWeightsFileName, msa);
return;
}
ValidateMuscleIds(msa);
if (1 == g_uMaxIters || 2 == uSeqCount)
{
//TextFile fileOut(g_pstrOutFileName, true);
//MHackEnd(msa);
//msa.ToFile(fileOut);
MuscleOutput(msa);
return;
}
if (0 == g_pstrUseTreeFileName)
{
g_bDiags = g_bDiags2;
SetIter(2);
if (g_bLow)
{
if (0 != g_uMaxTreeRefineIters)
RefineTreeE(msa, v, GuideTree, ProgNodes);
}
else
RefineTree(msa, GuideTree);
const char *Tree2 = ValueOpt("Tree2");
if (0 != Tree2)
{
TextFile f(Tree2, true);
GuideTree.ToFile(f);
}
}
SetSeqWeightMethod(g_SeqWeight2);
SetMuscleTree(GuideTree);
if (g_bAnchors)
RefineVert(msa, GuideTree, g_uMaxIters - 2);
else
RefineHoriz(msa, GuideTree, g_uMaxIters - 2, false, false);
#if 0
// Refining by subfamilies is disabled as it didn't give better
// results. I tried doing this before and after RefineHoriz.
// Should get back to this as it seems like this should work.
RefineSubfams(msa, GuideTree, g_uMaxIters - 2);
#endif
ValidateMuscleIds(msa);
ValidateMuscleIds(GuideTree);
//TextFile fileOut(g_pstrOutFileName, true);
//MHackEnd(msa);
//msa.ToFile(fileOut);
MuscleOutput(msa);
}
void Refine()
{
SetOutputFileName(g_pstrOutFileName.get());
SetInputFileName(g_pstrInFileName.get());
SetStartTime();
SetMaxIters(g_uMaxIters.get());
SetSeqWeightMethod(g_SeqWeight1.get());
TextFile fileIn(g_pstrInFileName.get());
MSA msa;
msa.FromFile(fileIn);
const unsigned uSeqCount = msa.GetSeqCount();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType.get())
{
case SEQTYPE_Auto:
Alpha = msa.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid SeqType");
}
SetAlpha(Alpha);
msa.FixAlpha();
SetPPScore();
if (ALPHA_DNA == Alpha || ALPHA_RNA == Alpha)
SetPPScore(PPSCORE_SPN);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
msa.SetSeqId(uSeqIndex, uSeqIndex);
SetMuscleInputMSA(msa);
Tree GuideTree;
TreeFromMSA(msa, GuideTree, g_Cluster2.get(), g_Distance2.get(), g_Root2.get());
SetMuscleTree(GuideTree);
if (g_bAnchors.get())
RefineVert(msa, GuideTree, g_uMaxIters.get());
else
RefineHoriz(msa, GuideTree, g_uMaxIters.get(), false, false);
ValidateMuscleIds(msa);
ValidateMuscleIds(GuideTree);
// TextFile fileOut(g_pstrOutFileName.get(), true);
// msa.ToFile(fileOut);
MuscleOutput(msa);
}
void ProgAlignSubFams()
{
MSA msaOut;
SetOutputFileName(g_pstrOutFileName.get());
SetInputFileName(g_pstrInFileName.get());
SetMaxIters(g_uMaxIters.get());
SetSeqWeightMethod(g_SeqWeight1.get());
TextFile fileIn(g_pstrInFileName.get());
SeqVect v;
v.FromFASTAFile(fileIn);
const unsigned uSeqCount = v.Length();
if (0 == uSeqCount)
Quit("No sequences in input file");
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType.get())
{
case SEQTYPE_Auto:
Alpha = v.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid seq type");
}
SetAlpha(Alpha);
v.FixAlpha();
PTR_SCOREMATRIX UserMatrix = 0;
if (0 != g_pstrMatrixFileName.get())
{
const char *FileName = g_pstrMatrixFileName.get();
const char *Path = getenv("MUSCLE_MXPATH");
if (Path != 0)
{
size_t n = strlen(Path) + 1 + strlen(FileName) + 1;
char *NewFileName = new char[n];
sprintf(NewFileName, "%s/%s", Path, FileName);
FileName = NewFileName;
}
TextFile File(FileName);
UserMatrix = ReadMx(File);
g_Alpha = ALPHA_Amino;
g_PPScore = PPSCORE_SP;
}
SetPPScore();
if (0 != UserMatrix)
g_ptrScoreMatrix = UserMatrix;
if (ALPHA_DNA == Alpha || ALPHA_RNA == Alpha)
{
SetPPScore(PPSCORE_SPN);
g_Distance1.get() = DISTANCE_Kmer4_6;
}
unsigned uMaxL = 0;
unsigned uTotL = 0;
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
{
unsigned L = v.GetSeq(uSeqIndex).Length();
uTotL += L;
if (L > uMaxL)
uMaxL = L;
}
SetIter(1);
g_bDiags.get() = g_bDiags1.get();
SetSeqStats(uSeqCount, uMaxL, uTotL/uSeqCount);
SetMuscleSeqVect(v);
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
v.SetSeqId(uSeqIndex, uSeqIndex);
if (uSeqCount > 1)
MHackStart(v);
if (0 == uSeqCount)
{
msaOut.Clear();
return;
}
if (1 == uSeqCount && ALPHA_Amino == Alpha)
{
const Seq &s = v.GetSeq(0);
msaOut.FromSeq(s);
return;
}
Tree GuideTree;
TreeFromSeqVect(v, GuideTree, g_Cluster1.get(), g_Distance1.get(), g_Root1.get());
SetMuscleTree(GuideTree);
MSA msa;
if (g_bLow.get())
{
ProgNode *ProgNodes = 0;
ProgNodes = ProgressiveAlignE(v, GuideTree, msa);
delete[] ProgNodes;
}
else
ProgressiveAlign(v, GuideTree, msa);
SetCurrentAlignment(msa);
TreeFromMSA(msa, GuideTree, g_Cluster2.get(), g_Distance2.get(), g_Root2.get());
SetMuscleTree(GuideTree);
unsigned *SubFams = new unsigned[uSeqCount];
unsigned uSubFamCount;
SubFam(GuideTree, g_uMaxSubFamCount.get(), SubFams, &uSubFamCount);
SetProgressDesc("Align node");
const unsigned uNodeCount = 2*uSeqCount - 1;
ProgNode *ProgNodes = new ProgNode[uNodeCount];
bool *NodeIsSubFam = new bool[uNodeCount];
bool *NodeInSubFam = new bool[uNodeCount];
for (unsigned i = 0; i < uNodeCount; ++i)
{
NodeIsSubFam[i] = false;
NodeInSubFam[i] = false;
}
for (unsigned i = 0; i < uSubFamCount; ++i)
{
unsigned uNodeIndex = SubFams[i];
assert(uNodeIndex < uNodeCount);
NodeIsSubFam[uNodeIndex] = true;
SetInFam(GuideTree, uNodeIndex, NodeInSubFam);
}
unsigned uJoin = 0;
unsigned uTreeNodeIndex = GuideTree.FirstDepthFirstNode();
do
{
if (NodeIsSubFam[uTreeNodeIndex])
{
#if TRACE
Log("Node %d: align subfam\n", uTreeNodeIndex);
#endif
ProgNode &Node = ProgNodes[uTreeNodeIndex];
AlignSubFam(v, GuideTree, uTreeNodeIndex, Node.m_MSA);
Node.m_uLength = Node.m_MSA.GetColCount();
}
else if (!NodeInSubFam[uTreeNodeIndex])
{
#if TRACE
Log("Node %d: align two subfams\n", uTreeNodeIndex);
#endif
Progress(uJoin, uSubFamCount - 1);
++uJoin;
const unsigned uMergeNodeIndex = uTreeNodeIndex;
ProgNode &Parent = ProgNodes[uMergeNodeIndex];
const unsigned uLeft = GuideTree.GetLeft(uTreeNodeIndex);
const unsigned uRight = GuideTree.GetRight(uTreeNodeIndex);
ProgNode &Node1 = ProgNodes[uLeft];
ProgNode &Node2 = ProgNodes[uRight];
PWPath Path;
AlignTwoMSAs(Node1.m_MSA, Node2.m_MSA, Parent.m_MSA, Path);
Parent.m_uLength = Parent.m_MSA.GetColCount();
Node1.m_MSA.Clear();
Node2.m_MSA.Clear();
}
else
{
#if TRACE
Log("Node %d: in subfam\n", uTreeNodeIndex);
#endif
;
}
uTreeNodeIndex = GuideTree.NextDepthFirstNode(uTreeNodeIndex);
}
while (NULL_NEIGHBOR != uTreeNodeIndex);
ProgressStepsDone();
unsigned uRootNodeIndex = GuideTree.GetRootNodeIndex();
ProgNode &RootProgNode = ProgNodes[uRootNodeIndex];
TextFile fOut(g_pstrOutFileName.get(), true);
MHackEnd(RootProgNode.m_MSA);
RootProgNode.m_MSA.ToFile(fOut);
delete[] NodeInSubFam;
delete[] NodeIsSubFam;
delete[] ProgNodes;
delete[] SubFams;
ProgNodes = 0;
NodeInSubFam = 0;
NodeIsSubFam = 0;
SubFams = 0;
}
void CSmilTranslatorTestUtils::RunTestL()
{
TRequestStatus *s = &iStatus;
// used to generate a leave if an out of memory error was encountered, specifically
// during the memory test loop in E32Main(). This is necessary because leaves in
// the .dll Active Object RunL() functions do not return to this application, so
// have to be Trapped in the Active objects and translated into an error code.
TBool memoryError = EFalse;
switch(iState)
{
case KInit:
{
// Utility class for file manipulation
iFileFinder = new TFindFile(iSession);
TPtrC errorFileName(KErrorFileName);
// create err dir if doesn't exist - this api ignores the file name (ignores everything after final '/')
fileSystem.MkDirAll(KErrorFileName);
// overwrite any existing file of this name
iErr = iErrorFile.Replace(iSession, errorFileName, EFileWrite | EFileStreamText);
if(iErr == KErrNone)
{
TBuf<1> bom;
bom.Append(CEditableText::EByteOrderMark);
iErrorFile.Write(DES_AS_8_BIT(bom));
// will search multiple directories, but halt after completing current directory
// if at least one match is made. Remembers which directories have been searched
// in order to continue search using .FindWild() function later
iErr = iFileFinder->FindWildByPath(KWildName, &KInputPathList, iFileList);
iIndex = 0;
}
if(iErr == KErrNone)
{
iState = KParseFile;
}
else
{
iState = KEnd;
}
User::RequestComplete(s, KErrNone);
SetActive();
}
break;
case KParseFile:
{
++iFilesProcessed;
iErr = KErrNone;
TParse fullEntry;
fullEntry.Set((*iFileList)[iIndex++].iName,& iFileFinder->File(),NULL);
iInputFileName = fullEntry.FullName(); // extract individual path + name from list
SetOutputFileName(); // output name is based on input one
iOutputMsg = KStartFile;
iOutputMsg.Append(iInputFileName); // display full path
test.Start(iOutputMsg); // print to console
// test console automatically places output on a new line, for output
// to error file we need to add white space ready for next line
iOutputMsg.Append(KOutputNewLine);
iErrorFile.Write(DES_AS_8_BIT(iOutputMsg)); // print to error file
// schedule Parser active object for call to it's RunL function
if (testConfig->DataMode() == CTestConfig::EBufferData)
{
// We're testing the buffering API...
// Create a data supplier object and pass it in to the parser
delete iDataSupplier;
iDataSupplier = NULL;
iDataSupplier = CTestDataSupplier::NewL(iSession, iInputFileName);
iParser->ParseSource(iDataSupplier);
}
else
{
if( iUseFileHandle )
{
RFile file;
User::LeaveIfError(file.Open(iSession, iInputFileName, EFileRead | EFileShareReadersOnly));
// No function declaration of ParseFile() that take RFile Object parameter
// iParser->ParseFile(file);
iParser->ParseFile(iSession, iInputFileName);
}
else
{
// We're testing the file mode so parse the file.
iParser->ParseFile(iSession, iInputFileName);
}
}
iState = KCheckResults;
iStatus = KRequestPending;
SetActive();
}
break;
case KCheckResults:
{
// when execution begins again one parse followed by a compose would have
// completed for the current file, handle any error messages generated here
iErr = iParser->Error();
TInt severity = iParser->ErrorSeverity();
if(iErr != KErrNone)
{
iOutputMsg = KParseError;
AppendErrorStr(iErr, iOutputMsg);
AppendSeverityStr(severity, iOutputMsg);
iOutputMsg.Append(KOutputNewLine);
// IF there are no more errors for this file bung in an
// extra line to make output more prominent
if(iComposer->Error() == KErrNone)
{
iOutputMsg.Append(KOutputNewLine);
}
test.Printf(iOutputMsg); // print to console
iErrorFile.Write(DES_AS_8_BIT(iOutputMsg)); // print to error file
if(iErr == KErrNoMemory)
{
memoryError = ETrue;
}
}
iErr = iComposer->Error();
severity = iComposer->ErrorSeverity();
if(iErr != KErrNone)
{
iOutputMsg = KComposeError;
AppendErrorStr(iErr, iOutputMsg);
AppendSeverityStr(severity, iOutputMsg);
iOutputMsg.Append(KOutputNewLine);
iOutputMsg.Append(KOutputNewLine);
test.Printf(iOutputMsg);
iErrorFile.Write(DES_AS_8_BIT(iOutputMsg));
if(iErr == KErrNoMemory)
{
memoryError = ETrue;
}
}
test.End();
// if the OOM condition occured during Parsing or Composing
if(memoryError)
{
User::Leave(KErrNoMemory);
}
iState = KParseFile;
if(iIndex >= iFileList->Count())
{
// fileList must be deleted after each loop prior to being passed
// back to fileFinder (unnecessary after KErrNotFound)
delete iFileList;
iFileList = 0; // Just in case it doesn't get set in the FindWild
// continue wildcard search for next directory in list
iErr = iFileFinder->FindWild(iFileList);
iIndex = 0;
if(iErr != KErrNone)
iState = KEnd;
}
SetActive();
User::RequestComplete(s, KErrNone);
}
break;
default:
case KEnd:
{
TTime endTime;
TTimeIntervalSeconds interval;
endTime.UniversalTime();
endTime.SecondsFrom(iStartTime, interval);
TBuf<100> time;
_LIT(KComposeTime, "Total time for composing: %d microseconds\n");
time.Format(KComposeTime, iComposeTime);
iErrorFile.Write(DES_AS_8_BIT(time));
_LIT(KTimeTaken, "Total time for tests: %d seconds");
time.Format(KTimeTaken, interval.Int());
iErrorFile.Write(DES_AS_8_BIT(time));
delete iFileFinder;
delete iDataSupplier;
CActiveScheduler::Stop();
}
break;
}
}
void DoRefineW()
{
SetOutputFileName(g_pstrOutFileName);
SetInputFileName(g_pstrInFileName);
SetStartTime();
SetMaxIters(g_uMaxIters);
SetSeqWeightMethod(g_SeqWeight1);
TextFile fileIn(g_pstrInFileName);
MSA msa;
msa.FromFile(fileIn);
const unsigned uSeqCount = msa.GetSeqCount();
if (0 == uSeqCount)
Quit("No sequences in input file");
MSA::SetIdCount(uSeqCount);
// Initialize sequence ids.
// From this point on, ids must somehow propogate from here.
for (unsigned uSeqIndex = 0; uSeqIndex < uSeqCount; ++uSeqIndex)
msa.SetSeqId(uSeqIndex, uSeqIndex);
SetMuscleInputMSA(msa);
ALPHA Alpha = ALPHA_Undefined;
switch (g_SeqType)
{
case SEQTYPE_Auto:
Alpha = msa.GuessAlpha();
break;
case SEQTYPE_Protein:
Alpha = ALPHA_Amino;
break;
case SEQTYPE_DNA:
Alpha = ALPHA_DNA;
break;
case SEQTYPE_RNA:
Alpha = ALPHA_RNA;
break;
default:
Quit("Invalid SeqType");
}
SetAlpha(Alpha);
msa.FixAlpha();
if (ALPHA_DNA == Alpha || ALPHA_RNA == Alpha)
SetPPScore(PPSCORE_SPN);
MSA msaOut;
RefineW(msa, msaOut);
// ValidateMuscleIds(msa);
// TextFile fileOut(g_pstrOutFileName, true);
// msaOut.ToFile(fileOut);
MuscleOutput(msaOut);
}
// ----------------------------------------------------------------------------
// MAINLINE LOGIC
// ----------------------------------------------------------------------------
int main() {
// declarations
int action = UNSET;
char rawPT[BUFFER_SIZE] = "";
char cleanPT[BUFFER_SIZE] = "";
int a = A, b = B, inverse = INVERSE, n = ALPHABET_SIZE;
char nameInputFile[30] = "input.txt" ;
char nameOutputFile[30] = "output.txt";
// seed the random number generator
srand((unsigned int)time(NULL));
// get ready
action = fGetClnStr(action, rawPT, cleanPT);
// display title page
DispHeader(nameInputFile, nameOutputFile, a, b, inverse);
puts("Welcome to Derrida - the command line Affine Cipher!");
Pause();
// detail loop
while(action != QUIT) {
ClearScreen();
DispHeader(nameInputFile, nameOutputFile, a, b, inverse);
// select an action
action = SelectAction(action);
DispHeader(nameInputFile, nameOutputFile, a, b, inverse);
// execute action
switch(action) {
case SET_I_FILE: // change the input file
action = fGetClnStr(action, rawPT, cleanPT, nameInputFile);
break;
case SET_O_FILE: // change the output file
action = SetOutputFileName(nameOutputFile);
break;
case DIR_LIST: // display directory listing
list_dir();
break;
case SET_KEY: // change cipher key
action = SetCipherKey(a, b, n, inverse);
break;
case ENCRYPT: // encrypt the PT codes
// display the string before encryption
printf("Before encryption, the string contains:\n");
puts(rawPT);
printf("\n");
printf("Sanatized, the string contains:\n");
puts(cleanPT);
printf("\n");
// if encryption succeeds, inform the user
if(EncryptString(cleanPT, a, b, n)) {
FileOutput(nameOutputFile, cleanPT);
printf("After encryption, the string contains:\n");
puts(cleanPT);
printf("\n");
}
Pause();
break;
case DECRYPT:
// display the clean cipher code before decryption
puts("Before decryption, the string contains:");
puts(cleanPT);
puts("\n");
// if decryption succeeds, inform the user
if(DecryptString(cleanPT, a, b, n)) {
FileOutput(nameOutputFile, cleanPT);
puts("After decryption, the string contains:\n");
puts(cleanPT);
puts("\n");
}
Pause();
break;
}
}
puts("The program will now exit.");
Pause();
// exit program
return 0;
}