--- /dev/null
+#include <map>
+#include <list>
+#include <fstream>
+#include <iostream>
+#include "gdcmHeader.h"
+
+//Generated file:
+#include "gdcmDataImages.h"
+
+using namespace std;
+
+typedef string EntryValueType; // same type as gdcmValEntry::value
+typedef list<gdcmTagKey, EntryValueType> ListEntryValues;
+typedef string FileNameType;
+typedef map<FileNameType, ListEntryValues*> MapFileValuesType;
+
+class ReferenceFileParser
+{
+ istream& eatwhite(istream& is);
+ void eatwhite(string& toClean);
+ string ExtractFirstString(string& toSplit);
+ string ExtractValue(string& toSplit);
+ void CleanUpLine( string& line );
+ void DisplayLine();
+
+ bool FirstPassReferenceFile();
+ bool SecondPassReferenceFile();
+ bool HandleFileName( string& line );
+ bool HandleKey( string& line );
+ bool HandleValue( string& line );
+public:
+ ReferenceFileParser();
+ bool Open( string& referenceFileName );
+private:
+ /// The ifstream attached to the file we parse:
+ ifstream from;
+
+ /// True when things went wrong, false otherwise
+ bool ParsingFailed;
+
+ /// String prefixing every output
+ string Indent;
+
+ /// The current line position within the stream:
+ int lineNumber;
+
+ string CurrentFileName;
+ string CurrentKey;
+ string CurrentValue;
+ string CurrentErrorMessage;
+};
+
+istream& ReferenceFileParser::eatwhite( istream& is )
+{
+ char c;
+ while (is.get(c)) {
+ if (!isspace(c)) {
+ is.putback(c);
+ break;
+ }
+ }
+ return is;
+}
+
+void ReferenceFileParser::eatwhite( string& toClean )
+{
+ while( toClean.find_first_of( " " ) == 0 )
+ toClean.erase( 0, toClean.find_first_of( " " ) + 1 );
+}
+
+string ReferenceFileParser::ExtractFirstString( string& toSplit )
+{
+ std::string firstString;
+ eatwhite( toSplit );
+ if ( toSplit.find( " " ) == string::npos ) {
+ firstString = toSplit;
+ toSplit.erase();
+ return firstString;
+ }
+ firstString = toSplit.substr( 0, toSplit.find(" ") );
+ toSplit.erase( 0, toSplit.find(" ") + 1);
+ eatwhite( toSplit );
+ return firstString;
+}
+
+string ReferenceFileParser::ExtractValue( string& toSplit )
+{
+ eatwhite( toSplit );
+ string::size_type beginPos = toSplit.find_first_of( '"' );
+ string::size_type endPos = toSplit.find_last_of( '"' );
+
+ // Make sure we have at most to " in toSplit:
+ string noQuotes = toSplit.substr( beginPos + 1, endPos - beginPos - 1);
+ if ( noQuotes.find_first_of( '"' ) != string::npos )
+ {
+ CurrentErrorMessage = "more than two quote character";
+ return string();
+ }
+
+ // No leading quote means this is not a value:
+ if ( beginPos == string::npos )
+ {
+ return string();
+ }
+
+ if ( ( endPos == string::npos ) || ( beginPos == endPos ) )
+ {
+ CurrentErrorMessage = "unmatched \" (quote character)";
+ return string();
+ }
+
+ if ( beginPos != 0 )
+ {
+ ostringstream error;
+ error << "leading character ["
+ << toSplit.substr(beginPos -1, 1)
+ << "] before opening \" ";
+ CurrentErrorMessage = error.str();
+ return string();
+ }
+
+ // When they are some extra characters at end of value, it must
+ // be a space:
+ if ( ( endPos != toSplit.length() - 1 )
+ && ( toSplit.substr(endPos + 1, 1) != " " ) )
+ {
+ ostringstream error;
+ error << "trailing character ["
+ << toSplit.substr(endPos + 1, 1)
+ << "] after value closing \" ";
+ CurrentErrorMessage = error.str();
+ return string();
+ }
+
+ string value = toSplit.substr( beginPos + 1, endPos - beginPos - 1 );
+ toSplit.erase( beginPos, endPos - beginPos + 1);
+ eatwhite( toSplit );
+ return value;
+}
+
+/// \brief Checks the block syntax of the incoming ifstream. Checks that
+/// - no nested blocks are present
+/// - we encounter a matching succesion of "[" and "]"
+/// - when ifstream terminates the last block is closed.
+/// - a block is not opened and close on the same line
+/// @param from The incoming ifstream to be checked.
+/// @return True when incoming ifstream has a correct syntax, false otherwise.
+/// \warning The underlying file pointer is not preseved.
+bool ReferenceFileParser::FirstPassReferenceFile()
+{
+ string line;
+ lineNumber = 1;
+ bool inBlock = false;
+ from.seekg( 0, ios::beg );
+
+ while ( ! from.eof() )
+ {
+ getline( from, line );
+
+ /// This is how we usually end the parsing because we hit EOF:
+ if ( ! from.good() )
+ {
+ if ( ! inBlock )
+ break;
+ else
+ {
+ cerr << Indent << "Syntax error: EOF reached when in block." << endl;
+ ParsingFailed = true;
+ break;
+ }
+ }
+
+ // Don't try to parse comments (weed out anything after first "#"):
+ if ( line.find_first_of( "#" ) != string::npos )
+ {
+ line.erase( line.find_first_of( "#" ) );
+ }
+
+ // Two occurences of opening blocks on a single line implies nested
+ // blocks which is illegal:
+ if ( line.find_first_of( "[" ) != line.find_last_of( "[" ) )
+ {
+ cerr << Indent
+ << "Syntax error: nested block (open) in reference file"
+ << endl
+ << Indent << "at line " << lineNumber << endl;
+ ParsingFailed = true;
+ break;
+ }
+
+ // Two occurences of closing blocks on a single line implies nested
+ // blocks which is illegal:
+ if ( line.find_first_of( "]" ) != line.find_last_of( "]" ) )
+ {
+ cerr << Indent
+ << "Syntax error: nested block (close) in reference file"
+ << endl
+ << Indent << "at line " << lineNumber << endl;
+ ParsingFailed = true;
+ break;
+ }
+
+ bool beginBlock ( line.find_first_of("[") != string::npos );
+ bool endBlock ( line.find_last_of("]") != string::npos );
+
+ // Opening and closing of block on same line:
+ if ( beginBlock && endBlock )
+ {
+ cerr << Indent
+ << "Syntax error: opening and closing on block on same line "
+ << lineNumber++ << endl;
+ ParsingFailed = true;
+ break;
+ }
+
+ // Illegal closing block when block not open:
+ if ( !inBlock && endBlock )
+ {
+ cerr << Indent << "Syntax error: unexpected end of block at line "
+ << lineNumber++ << endl;
+ ParsingFailed = true;
+ break;
+ }
+
+ // Uncommented line outside of block is not clean:
+ if ( !inBlock && !beginBlock )
+ {
+ cout << Indent
+ << "Syntax warning: outside of block [] data at line "
+ << lineNumber++ << " not considered." << endl;
+ continue;
+ }
+
+ if ( inBlock && beginBlock )
+ {
+ cerr << " Syntax error: illegal opening of nested block at line "
+ << lineNumber++ << endl;
+ ParsingFailed = true;
+ break;
+ }
+
+ // Normal situation of opening block:
+ if ( beginBlock )
+ {
+ inBlock = true;
+ lineNumber++;
+ continue;
+ }
+
+ // Normal situation of closing block:
+ if ( endBlock )
+ {
+ inBlock = false;
+ lineNumber++;
+ continue;
+ }
+ // This line had no block delimiter
+ lineNumber++;
+ }
+
+ // We need rewinding:
+ from.clear();
+ from.seekg( 0, ios::beg );
+
+ return ! ParsingFailed;
+}
+
+ReferenceFileParser::ReferenceFileParser()
+{
+ lineNumber = 1;
+ ParsingFailed = false;
+ Indent = " ";
+}
+
+bool ReferenceFileParser::Open( string& referenceFileName )
+{
+ from.open( referenceFileName.c_str(), ios::in );
+ if ( !from.is_open() )
+ {
+ cerr << Indent << "Can't open reference file." << endl;
+ ParsingFailed = true;
+ }
+
+ if ( !FirstPassReferenceFile() )
+ return false;
+
+ SecondPassReferenceFile();
+ from.close();
+}
+
+void ReferenceFileParser::CleanUpLine( string& line )
+{
+ // Cleanup from comments:
+ if ( line.find_first_of( "#" ) != string::npos )
+ line.erase( line.find_first_of( "#" ) );
+
+ // Cleanup everything after end block delimiter:
+ if ( line.find_last_of( "]" ) != string::npos )
+ line.erase( line.find_last_of( "]" ) + 1 );
+
+ // Cleanup leanding whites and skip empty lines:
+ eatwhite( line );
+}
+
+bool ReferenceFileParser::HandleFileName( string& line )
+{
+ if ( line.length() == 0 )
+ {
+ CurrentErrorMessage = "unfound filename";
+ return false;
+ }
+ if ( CurrentFileName.length() != 0 )
+ return true;
+ CurrentFileName = ExtractFirstString(line);
+ cout << Indent << "Found filename " << CurrentFileName << endl;
+ return true;
+}
+
+bool ReferenceFileParser::HandleKey( string& line )
+{
+ if ( line.length() == 0 )
+ return false;
+
+ if ( CurrentKey.length() != 0 )
+ return false;
+
+ CurrentKey = ExtractFirstString(line);
+ if ( CurrentKey.find_first_of( "|" ) == string::npos )
+ {
+ ostringstream error;
+ error << "uncorrect key:" << CurrentKey;
+ CurrentErrorMessage = error.str();
+ return false;
+ }
+ cout << Indent << "Found key:" << CurrentKey << endl;
+ return true;
+}
+
+bool ReferenceFileParser::HandleValue( string& line )
+{
+ if ( line.length() == 0 )
+ {
+ CurrentErrorMessage = "no value present";
+ return false;
+ }
+
+ if ( CurrentKey.length() == 0 )
+ {
+ cout << Indent << "No key present:" << CurrentKey << endl;
+ return false;
+ }
+
+ string newCurrentValue = ExtractValue(line);
+ if ( newCurrentValue.length() == 0 )
+ {
+ if ( CurrentErrorMessage.length() == 0 )
+ {
+ ostringstream error;
+ error << "missing value for key:" << CurrentKey;
+ CurrentErrorMessage = error.str();
+ }
+ return false;
+ }
+
+ cout << Indent << "Found value:" << newCurrentValue << endl;
+ CurrentValue += newCurrentValue;
+ return true;
+}
+
+void ReferenceFileParser::DisplayLine()
+{
+ cerr << Indent << "Syntax error at line " << lineNumber
+ << ": " << CurrentErrorMessage << "." << endl;
+}
+
+bool ReferenceFileParser::SecondPassReferenceFile()
+{
+ gdcmTagKey key;
+ EntryValueType value;
+ string line;
+ bool inBlock = false;
+ lineNumber = 0;
+
+ while ( !from.eof() )
+ {
+ getline( from, line );
+ lineNumber++;
+
+ CleanUpLine( line );
+
+ // Empty lines don't require any treatement:
+ if ( line.length() == 0 )
+ continue;
+
+ bool beginBlock ( line.find_first_of("[") != string::npos );
+ bool endBlock ( line.find_last_of("]") != string::npos );
+
+ // Waiting for a block to be opened. Meanwhile, drop everything:
+ if ( !inBlock && !beginBlock )
+ continue;
+
+ if ( beginBlock )
+ {
+ cout << Indent << "Begin block" << endl;
+ inBlock = true;
+ line.erase( 0, line.find_first_of( "[" ) + 1 );
+ eatwhite( line );
+ }
+ else if ( endBlock )
+ {
+ cout << Indent << "Detected End block" << endl;
+ line.erase( line.find_last_of( "]" ) );
+ eatwhite( line );
+ }
+
+ // Outside block lines are dropped:
+ if ( ! inBlock )
+ continue;
+
+ cout << Indent << "Default case:" << line << endl;
+
+ // First thing is to get a filename:
+ if ( ( ! HandleFileName( line ) ) && ( line.length() != 0 ) )
+ {
+ DisplayLine();
+ return false;
+ }
+
+ // Second thing is to get a key:
+ if ( ( ! HandleKey( line ) ) && ( line.length() != 0 ) )
+ {
+ ParsingFailed = true;
+ }
+
+ // Third thing is to get a value:
+ if ( ( ! ParsingFailed )
+ && ( ! HandleValue( line ) )
+ && ( line.length() != 0) )
+ {
+ ParsingFailed = true;
+ }
+
+ if ( ( ! ParsingFailed )
+ && CurrentKey.length()
+ && CurrentValue.length() )
+ {
+ cout << Indent << "Need to handle pair ("
+ << CurrentKey << ", " << CurrentValue << ")." << endl;
+ CurrentKey.erase();
+ CurrentValue.erase();
+ }
+
+ if ( ParsingFailed )
+ {
+ DisplayLine();
+ return false;
+ }
+
+ if ( endBlock )
+ {
+ cout << Indent << "Need to handle end of block " << endl;
+ inBlock = false;
+ CurrentFileName.erase();
+ }
+
+ //key = TranslateToKey(group, element);
+ ///tb1[key] = name.c_str();
+ //cout << group << element << vr << fourth << name;
+ //tb1[key] = "bozo";
+ }
+}
+
+int TestAllEntryVerify(int argc, char* argv[])
+{
+ if ( argc > 1 )
+ {
+ cerr << " Usage: " << argv[0]
+ << " (no arguments needed)." << endl;
+ return 1;
+ }
+
+ cout << " Description (Test::TestAllEntryVerify): "
+ << endl;
+ cout << " For all images in gdcmData (and not blacklisted in "
+ "Test/CMakeLists.txt)"
+ << endl;
+ cout << " apply the following to each filename.xxx: "
+ << endl;
+ cout << " step 1: parse the image (as gdcmHeader) and call"
+ << " IsReadable(). "
+ << endl;
+
+ string referenceFilename = GDCM_DATA_ROOT;
+ referenceFilename += "/"; //doh!
+ referenceFilename += "TestAllEntryVerifyReference.txt";
+
+ ReferenceFileParser Parser;
+ Parser.Open(referenceFilename);
+/*
+ int i = 0;
+ while( gdcmDataImages[i] != 0 )
+ {
+ string filename = GDCM_DATA_ROOT;
+ filename += "/"; //doh!
+ filename += gdcmDataImages[i++];
+
+ cout << " Testing: " << filename << endl;
+
+ gdcmHeader* tested = new gdcmHeader( filename.c_str(), false, true );
+ if( !tested->GetHeader()->IsReadable() )
+ {
+ cout << " Image not gdcm compatible:"
+ << filename << endl;
+ delete tested;
+ return 1;
+ }
+
+ //////////////// Clean up:
+ delete tested;
+ }
+*/
+
+ return 0;
+}
projects / gdcm.git / commitdiff