Advanced File and String Operations - c++

Question

So I am working on a model loader in my DirectX 11 program, and I ran into what I think is a unique issue. So I spent a bit of time looking for a solution to this, but failed to do so. My problem is that in my file that has the texture path and list of vertices, I want to be able to pick out certain parts, and remove some aswell. Below my example file for a texture-less triangle:
T:0$
(0, 5, 0)
(5, 0, 0)
(-5, 0, 0)
^ THIS IS OLD, LOOK AT EDIT BELOW ^
Let me explain what's happening here. First, the "T:___" is my file path to the texture. I have set this to "0" because I am not using a texture. The "$" after the "T:0" is my program's mark for the end of the file path and beginning of the vertices.
Now, here is what I need my program to do.
1. Read the file until the character "$" has been reached. Then erase the first two characters(the "T:") and the "$" if it has been added as well. Finally put the remaining text into a string called TextureData. P.S. Don't erase the "T:" from the file, just my string(The file needs to stay untouched).
2. Put the remaining text(vertices) into a temporary string called VertexData, then maybe remove the parenthesis..? I would like to know how to do this, but maybe not use it at the moment.
I hope I made myself and my issue clear enough.
Thanks in advance.
--- IMPORTANT EDIT ---
I have changed my format a little bit, I looked at a .obj file and decided that that would be easier to do. My texture and vertex file now looks like this:
T:0$
v 0 5 0
v 5 0 0
v -5 0 0
--- END OF EDIT ---
This code here is what I have as a basis:
Model loading function:
bool LoadTVF(string FP)
{
ifstream TVFReader;
TVFReader.open(FP);
if (TVFReader.is_open())
{
ReadLine(1); // Function not fully working, need to improve
// Load vertices and texture into strings
TVFReader.close();
return true;
}
else
{
return false;
}
}
ReadLine function(made just to organize my code and jump to a certain line and retrieve that lines data and put into a string, the cutting and modifying of the string needs to be back in the main function):
string ReadLine(int character)
{
return lineData; // I know this doesn't work, just don't know what to return?
}
Honestly with this ReadLine function, I have no idea what I'm doing. I was just making some kind of frame to show you how I would prefer the code to be organized.
Once again, thank you.

Answer 1

This is how I would do it:
bool LoadTVF(string FP)
{
ifstream TVFReader;
TVFReader.open(FP);
if (TVFReader.is_open()) {
stringstream buffer;
buffer << TVFReader.rdbuf();
string texture_string = buffer.str();
texture_string = texture_string.substr(2, texture_string.length());
// Removes T:
texture_string.erase(texture_string.begin() + texture_string.find("$"));
// Removes the first occurrence of $
std::cout << texture_string;
/* This will print out:
* 0
* v 0 5 0
* v 5 0 0
* v -5 0 0
*/
TVFReader.close();
return true;
}
else
{
return false;
}
}
This doesn't use a ReadLine function because it loads the entire string at once. Since I'm only manipulating that string at the beginning, I would rather have the parsing and pruning logic happen in one place.
If you must iterate line-by-line, there's already a way to do that using getline:
bool LoadTVF(string FP)
{
ifstream TVFReader;
TVFReader.open(FP);
if (TVFReader.is_open()) {
string line;
while(getline(TVFReader, line))
{
// Do stuff with each line
}
TVFReader.close();
return true;
}
else
{
return false;
}
}
Note that these lines don't have end-of-line characters in them.
Edit:
As per OP's comments, here's how you would split up the parsed file into separate strings:
bool LoadTVF(string FP)
{
ifstream TVFReader;
TVFReader.open(FP);
if (TVFReader.is_open()) {
string header;
getline(TVFReader, header);
header = header.substr(2, header.length());
// Removes T:
header.erase(header.begin() + header.find("$"));
// Removes the first occurrence of $
std::cout << header << std::endl;
// This should print 0, which is the string between T: and $
stringstream buffer;
string line;
while (getline(TVFReader, line))
{
line = line.substr(2, line.length());
// Removes the starting "v "
buffer << line << std::endl;
// We need the end-of-line here because its been stripped
}
string texture_string = buffer.str();
std::cout << texture_string;
/* This will print out:
* 0 5 0
* 5 0 0
* -5 0 0
*/
TVFReader.close();
return true;
}
else
{
return false;
}
}
A few notes I'd like to make here. If you're in control of the way your file is structured, you shouldn't need the $ character to indicate the end of that line. The fact that there's a newline should be indication enough of that. Additionally, since every line after that represents a vector in a matrix, I don't think the v is necessary either. Finally, the T: may also be unnecessary if your files are named appropriately, like "test.texture". That way you know that the file you're reading is a texture.
This would reduce the complexity of parsing these files, and as a bonus, reduces the storage sizes for these as well.

Answer 2

So far it looks like you can read your file line by line using getline and then extract necessary information: figure out "line type" by checking first character, then depending on type either get substring with path or split line into chunks and convert them to floats.
Later when/if your file format becomes more complicated you might want to write a full blown parser probably using some sort of parser generator.