cWebshotsMisc.cpp

Go to the documentation of this file.

/*
    cWebshots - Webshots files handling classes
    Copyright (C) 2005  Hervé "Setaou" BRY <uwc at apinc dot org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#include "cWebshots.h"

#include <cstdio>
#include <sstream>

using namespace std;

namespace cWebshots
{

        string GetFileName(string path)
        {
                size_t start = path.rfind("\\") + 1;
                return path.substr(start,path.length() - start);
        }

        string GetDirectory(string path)
        {
                return path.substr(0,path.rfind("\\") + 1);
        }

        Webshots_Formats IdentifyFile(string File)
        {
                ifstream in_file;

                // Open the file
                in_file.open(File.c_str(), ios_base::in | ios_base::binary);

                if (in_file.is_open())
                {
                        return IdentifyFile(in_file);
                }
                else
                {
                        Exceptions::FileSystemError Err("Unable to open the file \"" + File + "\" for reading.");
                        throw Err;
                }
        }

        Webshots_Formats IdentifyFile(ifstream &in_file)
        {
                long File_Type;
                Webshots_Formats Type;

                // Read the first 4 bytes of the file
                in_file.seekg(0);
                in_file.read((char *)&File_Type, 4);

                switch (File_Type)
                {
                // WBC file
                case WBC_File_Marker:
                        Type = WBC;
                        break;

                // WBZ file
                case WBZ_File_Marker:
                        Type = WBZ;
                        break;

                // JPG File / WB1 File
                case WB1_File_Marker:
                case JFIF_File_Marker: 
                case EXIF_File_Marker:
                        Type = WB1;
                        break;

                // Unknown file format
                default:
                        Type = Unknown;
                }

                return Type;
        }


        void Tokenize(const string& str, vector<string>& tokens, const string& delimiters = " ")
        {
                // Skip delimiters at beginning.
                string::size_type lastPos = str.find_first_not_of(delimiters, 0);
                // Find first "non-delimiter".
                string::size_type pos = str.find_first_of(delimiters, lastPos);

                while (string::npos != pos || string::npos != lastPos)
                {
                        // Found a token, add it to the vector.
                        tokens.push_back(str.substr(lastPos, pos - lastPos));
                        // Skip delimiters.  Note the "not_of"
                        lastPos = str.find_first_not_of(delimiters, pos);
                        // Find next "non-delimiter"
                        pos = str.find_first_of(delimiters, lastPos);
                }
        }

        string GetINI(const string &Data, const string &Section, const string &Field)
        {
                vector<string> Lines;

                // Fill the vector Lines with each line of Data
                if (Data.find("\r\n") != string::npos)     // \r\n = Windows line break
                        Tokenize(Data, Lines, "\r\n");
                else if (Data.find("\n") == string::npos)  // \r = Mac line break
                        Tokenize(Data, Lines, "\r");
                else                                       // \n = UNIX line break
                        Tokenize(Data, Lines, "\n");

                int l;
                bool header_found = false;

                // For each line
                for (l = 0; l < Lines.size(); l++)
                {
                        // Found the header of the section
                        if (Lines[l] == "[" + Section + "]")
                                header_found = true;
                        // Found the beginning of the next section
                        else if (header_found && (Lines[l].find("[") == 0))
                        {
                                Exceptions::CorruptedData Err("The field \"" + Field + "\" was not foud in the section \"" + Section + "\".");
                                throw Err;
                        }
                        // Found the field
                        else if (header_found && (Lines[l].find(Field + "=") != string::npos))
                        {
                                return Lines[l].substr(Field.size() + 1);
                        }
                }

                Exceptions::CorruptedData Err("The section \"" + Section + "\" was not found.");
                throw Err;
        }

        string IntToStr(const int &i)
        {
                stringstream str;
                str << i;
                return str.str();
        }

        long StrToLong(const string &s)
        {
                stringstream str(s);
                long l = 0;

                str >> l;

                return l;
        }

}

---