ip2cparser.h

//------------------------------------------------------------------------------
// ip2cparser.h
//------------------------------------------------------------------------------
//
// 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., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301, USA.
//
//------------------------------------------------------------------------------
// Copyright (C) 2009 "Blzut3" <admin@maniacsvault.net>
//------------------------------------------------------------------------------
#ifndef __IP2CPARSER_H__
#define __IP2CPARSER_H__

#include "ip2c.h"
#include <QMutex>
#include <QThread>

class IP2CParser : public QObject
{
        Q_OBJECT

        public:
                IP2CParser(IP2C* pTargetDatabase);

                IP2C* ip2c() const { return pTargetDatabase; }

                bool isParsing() const { return bIsParsing; }

                bool readDatabase(const QString& filePath);
                void readDatabaseThreaded(const QString& filePath);

        signals:
                void parsingFinished(bool bSuccess);

        protected:
                class ConstructorDestructorParserStateSetter
                {
                        public:
                                ConstructorDestructorParserStateSetter(IP2CParser* pParser);
                                ~ConstructorDestructorParserStateSetter();

                        private:
                                IP2CParser* pParser;
                };

                class ParsingThread : public QThread
                {
                        public:
                                bool bSuccessState;
                                QString filePath;
                                IP2CParser* pParser;


                                ParsingThread(IP2CParser* pParser, const QString& filePath)
                                {
                                        bSuccessState = false;
                                        this->filePath = filePath;
                                        this->pParser = pParser;
                                }

                                void run();
                };

                typedef QHash<QString, QList<IP2C::IP2CData> > Countries;
                typedef QHash<QString, QList<IP2C::IP2CData> >::iterator CountriesIt;
                typedef QHash<QString, QList<IP2C::IP2CData> >::const_iterator CountriesConstIt;

                bool bIsParsing;
                ParsingThread* currentParsingThread;

                IP2C* pTargetDatabase;

                QMutex thisLock;


                bool convertAndSaveDatabase(QByteArray& downloadedData, const QString& outFilePath);

                void convertCountriesIntoBinaryData(const Countries& countries, QByteArray& output);

                bool doReadDatabase(const QString& filePath);

                bool readDatabaseVersion1(const QByteArray& dataArray);
                bool readDatabaseVersion2(const QByteArray& dataArray);

                void readTextDatabase(QByteArray& textDatabase, Countries& countries);

        protected slots:
                void parsingThreadFinished();
};

#endif