MyTranlatorParser Class Reference

Tranlator Parser. More...

#include <MyTranlatorParser.h>

Inheritance diagram for MyTranlatorParser:

Public Member Functions
	MyTranlatorParser (MyLanguageModel *thisLanguageModel=nullptr, QObject *parent=nullptr)
	Translation Files Constructor. MyTranslationFiles. More...
base_node::base_node_ptr	parse_ts_file (const QString &inputFile)
	parse_ts_file More...
bool	parse_txt_file (const QString &inputFile, visitors::map_QStringQString &strings)
	parse_txt_file More...
void	toTXT (const QString &inputFile, const QString &outputDir, bool with_unfinished, bool with_vanished, bool unfinished_only)
	toTXT More...
void	toTS (const QString &inputDir, const QString &outputFile, const QString &langid)
	toTS More...
void	setDebugMessage (bool thisState)
	set Debug Message More...
bool	getDebugMessage ()
	get Debug Message More...
void	setMessage (const QString &thisMessage)
	set Message More...

Detailed Description

Tranlator Parser.

Definition at line 20 of file MyTranlatorParser.h.

Constructor & Destructor Documentation

MyTranlatorParser()

MyTranlatorParser::MyTranlatorParser ( MyLanguageModel *  thisLanguageModel = nullptr, QObject *  parent = nullptr  )

explicit

Translation Files Constructor. MyTranslationFiles.

Definition at line 7 of file MyTranlatorParser.cpp.

                                                                                        : QObject(parent), myLanguageModel(thisLanguageModel)
{
 
}

Member Function Documentation

getDebugMessage()

bool MyTranlatorParser::getDebugMessage

(

)

get Debug Message

parse_ts_file()

base_node::base_node_ptr MyTranlatorParser::parse_ts_file

(

const QString &

inputFile

)

parse_ts_file

parse ts file. parse_ts_file

Definition at line 15 of file MyTranlatorParser.cpp.

{
    QFile iFile(inputFile);
    iFile.open(QIODevice::ReadOnly);
 
    QXmlStreamReader xmlReader(&iFile);
 
    base_node::base_node_ptr root, current;
    QString text;
 
    enum EStates
    {
        st_Unstate             = 0,
        st_WaitForStartElement = 0x01,
        st_WaitForText         = 0x02,
        st_WaitForEndElement   = 0x04
    };
 
    int states = st_WaitForStartElement;
 
    while(!xmlReader.atEnd())
    {
        QXmlStreamReader::TokenType tt = xmlReader.readNext();
        switch(tt)
        {
            case QXmlStreamReader::StartDocument:
            {
                root = std::make_shared<document_node>();
                current = root;
            } break;
            case QXmlStreamReader::DTD:
            {
                current->add_child(std::make_shared<DTD_node>("<!DOCTYPE TS>"));
            } break;
            case QXmlStreamReader::StartElement:
            {
                assert(states & st_WaitForStartElement);
 
                QString name = xmlReader.name().toString();
                QXmlStreamAttributes attrs = xmlReader.attributes();
 
                if("message" == name)
                {
                    current = current->add_child(std::make_shared<element_node>(element_node::ent_message, name, attrs));
                }
                else if("source" == name)
                {
                    current = current->add_child(std::make_shared<element_node>(element_node::ent_source, name, attrs));
                }
                else if("translation" == name)
                {
                    current = current->add_child(std::make_shared<element_node>(element_node::ent_translation, name, attrs));
                }
                else if("TS" == name)
                {
                    current = current->add_child(std::make_shared<TS_node>(name, attrs));
                }
                else
                {
                    current = current->add_child(std::make_shared<element_node>(element_node::ent_element, name, attrs));
                }
 
                states = st_WaitForText|st_WaitForStartElement|st_WaitForEndElement;
            } break;
            case QXmlStreamReader::Characters:
            {
                if(states & st_WaitForText)
                {
                    text = xmlReader.text().toString();
                    states = st_WaitForEndElement|st_WaitForStartElement;
                }
            } break;
            case QXmlStreamReader::EndElement:
            {
                assert(states & st_WaitForEndElement);
                assert(current->kind() & base_node::nt_Element);
                //((element_node*)current.get())->set_text(text);
 
                reinterpret_cast<element_node*>(current.get())->set_text(text);
 
                text.clear();
                states = st_WaitForStartElement|st_WaitForEndElement;
                current = current->parent();
            } break;
            case QXmlStreamReader::Invalid:               { break; }
            case QXmlStreamReader::EndDocument:           { break; }
            case QXmlStreamReader::Comment:               { break; }
            case QXmlStreamReader::EntityReference:       { break; }
            case QXmlStreamReader::ProcessingInstruction: { break; }
            case QXmlStreamReader::NoToken:               { break; }
        }
    }
 
    return root;
}

parse_txt_file()

bool MyTranlatorParser::parse_txt_file	(	const QString &	inputFile,
		visitors::map_QStringQString &	strings
	)

parse_txt_file

parse txt file. parse_txt_file

Definition at line 114 of file MyTranlatorParser.cpp.

setDebugMessage()

void MyTranlatorParser::setDebugMessage

(

bool

thisState

)

set Debug Message

setMessage()

void MyTranlatorParser::setMessage

(

const QString &

thisMessage

)

set Message

toTS()

void MyTranlatorParser::toTS	(	const QString &	inputDir,
		const QString &	outputFile,
		const QString &	langid
	)

toTS

toTXT()

void MyTranlatorParser::toTXT	(	const QString &	inputFile,
		const QString &	outputDir,
		bool	with_unfinished,
		bool	with_vanished,
		bool	unfinished_only
	)

toTXT

---

The documentation for this class was generated from the following files:

• src/MyTranlatorParser.h
• src/MyTranlatorParser.cpp