From eec0075e549067c42ffffa673ce982b85c70d186 Mon Sep 17 00:00:00 2001 From: Dmitry Okunev Date: Fri, 13 Oct 2023 18:18:06 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A1hange=20of=20architecture?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../StarMath2OOXML/cconversionsmtoooxml.cpp | 29 +- .../StarMath2OOXML/cconversionsmtoooxml.h | 42 +- .../StarMath2OOXML/cstarmathpars.cpp | 1335 +++++------------ .../Converter/StarMath2OOXML/cstarmathpars.h | 221 +-- .../Converter/StarMath2OOXML/typeselements.h | 73 +- 5 files changed, 522 insertions(+), 1178 deletions(-) diff --git a/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.cpp b/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.cpp index f0988e010b..fcb9c297fb 100644 --- a/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.cpp +++ b/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.cpp @@ -1,7 +1,7 @@ #include "cconversionsmtoooxml.h" #include "../../../../DesktopEditor/common/File.h" #include -namespace StarMath { +/*namespace StarMath { CConversionSMtoOOXML::CConversionSMtoOOXML() { } @@ -14,17 +14,17 @@ namespace StarMath { ConversionOneElement(m_oTempElement); } EndConversion(); -// NSFile::CFileBinary oFile; -// oFile.CreateFileW(L"Test.txt"); -// oFile.WriteStringUTF8(m_oXmlWrite.GetXmlString()); -// oFile.CloseFile(); + NSFile::CFileBinary oFile; + oFile.CreateFileW(L"Test.txt"); + oFile.WriteStringUTF8(m_oXmlWrite.GetXmlString()); + oFile.CloseFile(); } void CConversionSMtoOOXML::ConversionOneElement(CElement *m_oElement) { switch (m_oElement->GetType()) { - case Number: - ConversNumber(dynamic_cast(m_oElement)); + case Text: + ConversText(dynamic_cast(m_oElement)); break; case BinOperator: ConversBinOperator(dynamic_cast (m_oElement)); @@ -40,7 +40,7 @@ namespace StarMath { { if(m_oElement->GetTypeBin() == plus || m_oElement->GetTypeBin() == minus || m_oElement->GetTypeBin() == multipl || m_oElement->GetTypeBin() == cdot || m_oElement->GetTypeBin() == times || m_oElement->GetTypeBin() == div || m_oElement->GetTypeBin() == odivide || m_oElement->GetTypeBin() == oplus || m_oElement->GetTypeBin() == ominus || m_oElement->GetTypeBin() == odot || m_oElement->GetTypeBin() == otimes) { - ConversionOneElement(m_oElement->GetLeftArg()); + ConversionOneElement(m_oElement->GetFirstElement()); m_oXmlWrite.WriteNodeBegin(L"m:r",false); StandartProperties(); m_oXmlWrite.WriteNodeBegin(L"m:t",false); @@ -80,9 +80,9 @@ namespace StarMath { default: break; } - if(m_oElement->GetTypeRight() == Number) + if(m_oElement->GetTypeSecondElement() == Text) { - CNumber* m_oNumber = dynamic_cast (m_oElement->GetRightArg()); + CText* m_oNumber = dynamic_cast (m_oElement->GetSecondElement()); m_oXmlWrite.WriteString(m_oNumber->GetValue()); m_oXmlWrite.WriteNodeEnd(L"m:t",false,false); m_oXmlWrite.WriteNodeEnd(L"m:r",false,false); @@ -91,7 +91,7 @@ namespace StarMath { { m_oXmlWrite.WriteNodeEnd(L"m:t",false,false); m_oXmlWrite.WriteNodeEnd(L"m:r",false,false); - ConversionOneElement(m_oElement->GetRightArg()); + ConversionOneElement(m_oElement->GetSecondElement()); } } @@ -100,12 +100,12 @@ namespace StarMath { m_oXmlWrite.WriteNodeBegin(L"m:f",false); if(m_oElement->GetTypeBin() == division) PropertiesMFPR(true,L"lin"); else PropertiesMFPR(false,L""); - BlockRecording(L"m:num",m_oElement->GetLeftArg()); - BlockRecording(L"m:den",m_oElement->GetRightArg()); + BlockRecording(L"m:num",m_oElement->GetFirstElement()); + BlockRecording(L"m:den",m_oElement->GetSecondElement()); m_oXmlWrite.WriteNodeEnd(L"m:f",false,false); } } - void CConversionSMtoOOXML::ConversNumber(CNumber *m_oElement) + void CConversionSMtoOOXML::ConversText(CText *m_oElement) { m_oXmlWrite.WriteNodeBegin(L"m:r",false); StandartProperties(); @@ -225,3 +225,4 @@ namespace StarMath { m_oXmlWrite.WriteNodeEnd(L"m:oMathPara",false,false); } } +*/ diff --git a/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.h b/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.h index 6c47b84ddf..1aa8b5f411 100644 --- a/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.h +++ b/OdfFile/Reader/Converter/StarMath2OOXML/cconversionsmtoooxml.h @@ -5,25 +5,25 @@ -namespace StarMath { - class CConversionSMtoOOXML - { - public: - CConversionSMtoOOXML(); - //friend class StarMath::CStarMathPars; - void StartConversion(std::vector arPars); - void StandartProperties(); - void PropertiesMFPR(bool bType,const std::wstring& wsType); - void PropertiesNaryPr(const std::wstring& wsTypeOperator,bool bEmptySub,bool bEmptySup); - void ConversionOneElement(CElement* m_oElement); - void ConversBinOperator(CBinaryOperator* m_oElement); - void ConversNumber(CNumber* m_oElement); - void ConversOperator(COperator* m_oElement); - void BlockRecording(const std::wstring& wsNameBlock,CElement* CValueBlock); - void EndConversion(); - std::wstring GetOOXML() ; - private: - XmlUtils::CXmlWriter m_oXmlWrite; - }; -} +//namespace StarMath { +// class CConversionSMtoOOXML +// { +// public: +// CConversionSMtoOOXML(); +// //friend class StarMath::CStarMathPars; +// void StartConversion(std::vector arPars); +// void StandartProperties(); +// void PropertiesMFPR(bool bType,const std::wstring& wsType); +// void PropertiesNaryPr(const std::wstring& wsTypeOperator,bool bEmptySub,bool bEmptySup); +// void ConversionOneElement(CElement* m_oElement); +// void ConversBinOperator(CBinaryOperator* m_oElement); +// void ConversText(CText* m_oElement); +// void ConversOperator(COperator* m_oElement); +// void BlockRecording(const std::wstring& wsNameBlock,CElement* CValueBlock); +// void EndConversion(); +// std::wstring GetOOXML() ; +// private: +// XmlUtils::CXmlWriter m_oXmlWrite; +// }; +//} #endif // CCONVERSIONSMTOOOXML_H diff --git a/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.cpp b/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.cpp index fd5de25f4e..65344bf039 100644 --- a/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.cpp +++ b/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.cpp @@ -1,62 +1,42 @@ #include "cstarmathpars.h" namespace StarMath { -//Class methods CStarMathPars - CStarMathPars::CStarMathPars() +//class methods CParsStarMath + std::vector CParseStarMathString::Parse(std::wstring& wsParseString) { - } - - CStarMathPars::~CStarMathPars() - { - for(CElement* ReleaseObject: m_arParsLine) + std::wstring::iterator itStart = wsParseString.begin(),itEnd = wsParseString.end(); + while(itStart != itEnd) { - delete ReleaseObject; + arEquation.push_back(ParsElement(itStart,itEnd)); } + return arEquation; } - void CStarMathPars::PrintAr() - { - for(int i = 0;iGetType(); - } - } -//Test version (works correctly only with operators, does not work correctly with attributes) - CElement* CStarMathPars::ReadWithoutBrackets(std::wstring::iterator &itFirst, std::wstring::iterator &itEnd,std::vector& arParsLine) + CElement* CParseStarMathString::ParsElement(std::wstring::iterator& itStart, std::wstring::iterator& itEnd) { - CElement* m_oOneElement = ParsElement(itFirst,itEnd,arParsLine); - if(m_oOneElement->GetType() != Bracket) + CElement* pElement; + std::wstring wsToken = GetElement(itStart,itEnd); + std::vector arAttributes; + TypeElement enTypeToken = CAttribute::IsAttribute(wsToken); + while(enTypeToken != TypeElement::undefine && itStart != itEnd) { - std::vector arTempValue; - arTempValue.push_back(m_oOneElement); - while(CheckingTheNextElement(itFirst,itEnd,CheckBinOperator)|| CheckingTheNextElement(itFirst,itEnd,CheckPlusOrMinus)||CheckingTheNextElement(itFirst,itEnd,CheckBinOperatorLowPriority)) - { - arTempValue.push_back(ParsElement(itFirst,itEnd,arTempValue)); - } - if(arTempValue.size()== 1) return m_oOneElement = arTempValue.back(); - else - { - CBracket* m_oBracket = new CBracket; - m_oBracket->SetBracketVal(arTempValue); - m_oBracket->SetTypeBracket(L"brace"); - return m_oBracket; - } - } - else return m_oOneElement; - } - - void CStarMathPars::Pars(std::wstring& wsStarMathLine) - { - std::wstring::iterator itFirst = wsStarMathLine.begin(), itEnd = wsStarMathLine.end(); - while(itFirst != itEnd) - { - m_arParsLine.push_back(ParsElement(itFirst,itEnd,m_arParsLine)); - //std::wcout << GetElement(itFirst,itEnd)<SetAttribute(arAttributes); + pElement->Pars(itStart,itEnd); + return pElement; + } + else return pElement; } - std::wstring CStarMathPars::GetElement(std::wstring::iterator& itFirst,std::wstring::iterator& itEnd) + std::wstring CParseStarMathString::GetElement(std::wstring::iterator& itFirst,std::wstring::iterator& itEnd) { std::wstring m_wsElement{}; for(; itFirst != itEnd;itFirst++) @@ -85,936 +65,411 @@ namespace StarMath if(!m_wsElement.empty()) return m_wsElement; else return {}; } - CElement* CStarMathPars::ParsElement(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd,std::vector& arParsLine) + bool CParseStarMathString::CheckingTheNextElement(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd, bool (&func)(const std::wstring&)) { - CAttribute* m_oAttribute = new CAttribute; - std::wstring wsOneElement = GetElement(itFirst,itEnd); - while((L"color" == wsOneElement && CheckingTheNextElement(itFirst,itEnd,CheckColorAttribute))|| CheckPropertiesAttribute(wsOneElement) || CheckTopAttribute(wsOneElement)) - { - if(wsOneElement == L"color") wsOneElement = GetElement(itFirst,itEnd); - m_oAttribute->SetTypeAtt(wsOneElement); - wsOneElement = GetElement(itFirst,itEnd); - } - - if(CheckDigit(wsOneElement)) - { - CNumber* m_oCNumber = new CNumber(wsOneElement); - m_oCNumber->SetAttribute(m_oAttribute); - return m_oCNumber; - } - else if(CheckSpecialCharacter(wsOneElement) || CheckSpecialOperation(wsOneElement) || CheckSpecialConnection(wsOneElement)) return new CSpecialSymbol(wsOneElement); - else if(CheckFunction(wsOneElement)) - { - CFunction* m_oFunction = new CFunction; - m_oFunction->SetTypeFunction(wsOneElement); - if(L"ln" == wsOneElement) m_oFunction->SetArgument(ReadWithoutBrackets(itFirst,itEnd,arParsLine)); - else m_oFunction->SetArgument(ParsElement(itFirst,itEnd,arParsLine)); - m_oFunction->SetAttribute(m_oAttribute); - return m_oFunction; - } - else if(CheckIndex(wsOneElement)) - { - CIndex* m_oIndex = new CIndex(wsOneElement); - m_oIndex->SetArgument(arParsLine.back()); - m_oIndex->SetIndex(ParsElement(itFirst,itEnd,arParsLine)); - return m_oIndex; - } - else if(CheckMatrix(wsOneElement)) - { - CMatrix* m_oMatrix = new CMatrix(wsOneElement); - m_oMatrix->SetArgument(ParsElement(itFirst,itEnd,arParsLine)); - m_oMatrix->SetAttribute(m_oAttribute); - return m_oMatrix; - } - else if(CheckBinOperator(wsOneElement) || CheckPlusOrMinus(wsOneElement) || CheckBinOperatorLowPriority(wsOneElement)) - { - if(!arParsLine.empty()) - { - CBinaryOperator* m_pBinOp = new CBinaryOperator(wsOneElement); - CElement* m_oTempElement{ParsElement(itFirst,itEnd,arParsLine)}; - m_pBinOp->SetArgument(arParsLine.back()); - arParsLine.pop_back(); - if(((CheckPlusOrMinus(wsOneElement) || CheckBinOperatorLowPriority(wsOneElement)) && (CheckingTheNextElement(itFirst, itEnd,CheckBinOperator)||CheckingTheNextElement(itFirst, itEnd, CheckIndex))) || (CheckBinOperator(wsOneElement) && CheckingTheNextElement(itFirst, itEnd,CheckIndex))) - { - arParsLine.push_back(m_oTempElement); - m_pBinOp->SetRightArg(ParsElement(itFirst,itEnd,arParsLine)); - } - else m_pBinOp->SetRightArg(m_oTempElement); - m_pBinOp->SetAttribute(m_oAttribute); - return m_pBinOp; - } - return NULL; - } - else if(CheckBracketOpen(wsOneElement) || CheckScalable_NotScalableBracketLeft(wsOneElement) || (L"left" == wsOneElement && CheckingTheNextElement(itFirst,itEnd,CheckScalable_NotScalableBracketLeft))) - { - CBracket* m_oBracket = new CBracket; - std::wstring wsTypeBracket; - std::vector arValueBrecket; - if(L"left" == wsOneElement) - { - m_oBracket->SetScalable(); - wsOneElement = GetElement(itFirst,itEnd); - wsTypeBracket = wsOneElement; - } - else wsTypeBracket = wsOneElement; - while(!CheckingTheNextElement(itFirst,itEnd,CheckBracketClose) && !CheckingTheNextElement(itFirst,itEnd,CheckScalable_NotScalableBracketRight)) - { - arValueBrecket.push_back(ParsElement(itFirst,itEnd,arValueBrecket)); - } - wsOneElement = GetElement(itFirst,itEnd); - if(L"right" == wsOneElement) wsOneElement = GetElement(itFirst,itEnd); - m_oBracket->SetBracketVal(arValueBrecket); - m_oBracket->SetTypeBracket(wsTypeBracket); - m_oBracket ->SetAttribute(m_oAttribute); - return m_oBracket; - } - else if(CheckOperator(wsOneElement)) - { - COperator* oTempOp = new COperator(wsOneElement); - std::vector arValueBrecket; - std::wstring::iterator itSavePos; - do - { - itSavePos = itFirst; - wsOneElement = GetElement(itFirst,itEnd); - if( wsOneElement == L"from") - oTempOp->SetFrom(ParsElement(itFirst,itEnd,arValueBrecket)); - else if(wsOneElement == L"to") - oTempOp->SetTo(ParsElement(itFirst,itEnd,arValueBrecket)); - else - break; - }while(true); - oTempOp->SetValueOp(ParsElement(itSavePos,itEnd,arValueBrecket)); - oTempOp->SetAttribute(m_oAttribute); - return oTempOp; - } + std::wstring::iterator itTempVal = itFirst; + std::wstring wsAttributeToken = GetElement(itFirst,itEnd); +// while(true) +// { +// if(wsAttributeToken == L"color") wsAttributeToken = GetElement(itFirst,itEnd); +// wsAttributeToken = GetElement(itFirst,itEnd); +// } + itFirst = itTempVal; + if(func(wsAttributeToken)) return true; + else return false; } - - bool CStarMathPars::CheckDigit(const std::wstring &wsCheckToken) +//class methods CAttribute + CAttribute::~CAttribute() + {} + CAttribute::CAttribute(const TypeElement &enType) { - for(char Check: wsCheckToken) + enTypeAttr = enType; + } + TypeElement CAttribute::GetType() + { + return enTypeAttr; + } +//нет phantom, rgb, 16 , гарнитуры и кегля + TypeElement CAttribute::IsAttribute(const std::wstring &wsToken) + { + if(L"acute" == wsToken) return TypeElement::acute; + else if(L"color" == wsToken) return TypeElement::color; + else if(L"breve" == wsToken) return TypeElement::breve; + else if(L"dot" == wsToken) return TypeElement::dot; + else if(L"dddot" == wsToken) return TypeElement::dddot; + else if(L"vec" == wsToken) return TypeElement::vec; + else if(L"tilde" == wsToken) return TypeElement::tilde; + else if(L"check" == wsToken) return TypeElement::check; + else if(L"grave" == wsToken) return TypeElement::grave; + else if(L"circle" == wsToken) return TypeElement::circle; + else if(L"ddot" == wsToken) return TypeElement::ddot; + else if(L"bar" == wsToken) return TypeElement::bar; + else if(L"harpoon" == wsToken) return TypeElement::harpoon; + else if(L"hat" == wsToken) return TypeElement::hat; + else if(L"widevec" == wsToken) return TypeElement::widevec; + else if(L"widetilde" == wsToken) return TypeElement::widetilde; + else if(L"overline" == wsToken) return TypeElement::overline; + else if(L"overstrike" == wsToken) return TypeElement::overstrike; + else if(L"wideharpoon" == wsToken) return TypeElement::wideharpoon; + else if(L"widehat" == wsToken) return TypeElement::widehat; + else if(L"underline" == wsToken) return TypeElement::underline; + else if(L"ital" == wsToken) return TypeElement::ital; + else if(L"bold" == wsToken) return TypeElement::bold; + else if(L"black" == wsToken) return TypeElement::black; + else if(L"green" == wsToken) return TypeElement::green; + else if(L"aqua" == wsToken) return TypeElement::aqua; + else if(L"yellow" == wsToken) return TypeElement::yellow; + else if(L"lime" == wsToken) return TypeElement::lime; + else if(L"navy" == wsToken) return TypeElement::navy; + else if(L"purple" == wsToken) return TypeElement::purple; + else if(L"teal" == wsToken) return TypeElement::teal; + else if(L"blue" == wsToken) return TypeElement::blue; + else if(L"red" == wsToken) return TypeElement::red; + else if(L"fuchsia" == wsToken) return TypeElement::fuchsia; + else if(L"gray" == wsToken) return TypeElement::gray; + else if(L"maroon" == wsToken) return TypeElement::maroon; + else if(L"olive" == wsToken) return TypeElement::olive; + else if(L"silver" == wsToken) return TypeElement::silver; + else if(L"coral" == wsToken) return TypeElement::coral; + else if(L"midnightblue" == wsToken) return TypeElement::midnightblue; + else if(L"crimson" == wsToken) return TypeElement::crimson; + else if(L"violet" == wsToken) return TypeElement::violet; + else if(L"orange" == wsToken) return TypeElement::orange; + else if(L"seagreen" == wsToken) return TypeElement::seagreen; + else if(L"hotpink" == wsToken) return TypeElement::hotpink; + else if(L"orangered" == wsToken) return TypeElement::orangered; + else if(L"indigo" == wsToken) return TypeElement::indigo; + else if(L"lavender" == wsToken) return TypeElement::lavender; + else return TypeElement::undefine; + } +//class methods CElement + CElement::~CElement() + {} + CElement::CElement() + {} +// TypeElement CElement::GetTypeElement(const std::wstring& wsToken) +// { +// if (wsToken == L"+") +// { +// return TypeElement::plus; +// } +// else if (wsToken == L"-") +// { +// return TypeElement::minus; +// } +// else if (wsToken == L"*") +// { +// return TypeElement::multipl; +// } +// else if (wsToken == L"/") +// { +// return TypeElement::division; +// } +// else if (wsToken == L"over") +// { +// return TypeElement::over; +// } +// else if (wsToken == L"cdot") +// { +// return TypeElement::cdot; +// } +// else if (wsToken == L"times") +// { +// return TypeElement::times; +// } +// else if (wsToken == L"frac") +// { +// return TypeElement::frac; +// } +// else if (wsToken == L"div") +// { +// return TypeElement::div; +// } +// else if (wsToken == L"oplus") +// { +// return TypeElement::oplus; +// } +// else if (wsToken == L"ominus") +// { +// return TypeElement::ominus; +// } +// else if (wsToken == L"odot") +// { +// return TypeElement::odot; +// } +// else if (wsToken == L"otimes") +// { +// return TypeElement::otimes; +// } +// else if (wsToken == L"odivide") +// { +// return TypeElement::odivide; +// } +// else if (wsToken == L"circ") +// { +// return TypeElement::circ; +// } +// else if (wsToken == L"wideslash") +// { +// return TypeElement::wideslash; +// } +// else if (wsToken == L"widebslash") +// { +// return TypeElement::widebslash; +// } +// else if(L"{" == wsToken) return TypeElement::brace; +// else if(L"(" == wsToken) return TypeElement::round; +// else if(L"[" == wsToken) return TypeElement::square; +// else if(L"ldbracket" == wsToken) return TypeElement::ldbracket; +// else if(L"lbrace" == wsToken) return TypeElement::lbrace; +// else if(L"langle" == wsToken) return TypeElement::langle; +// else if(L"lceil" == wsToken) return TypeElement::lceil; +// else if(L"lfloor" == wsToken) return TypeElement::lfloor; +// else if(L"lline" == wsToken) return TypeElement::lline; +// else if(L"ldline" == wsToken) return TypeElement::ldline; +// else return TypeElement::undefine; +// } + CElement* CElement::CreateElement(const std::wstring& wsToken) + { + //binop + if (wsToken == L"+") { - if(!isdigit(Check)) return false; + return new CElementBinOperator(TypeElement::plus); + } + else if (wsToken == L"-") + { + return new CElementBinOperator(TypeElement::minus); + } + else if (wsToken == L"*") + { + return new CElementBinOperator(TypeElement::multipl); + } + else if (wsToken == L"/") + { + return new CElementBinOperator(TypeElement::division); + } + else if (wsToken == L"over") + { + return new CElementBinOperator(TypeElement::over); + } + else if (wsToken == L"cdot") + { + return new CElementBinOperator(TypeElement::cdot); + } + else if (wsToken == L"times") + { + return new CElementBinOperator(TypeElement::times); + } + else if (wsToken == L"frac") + { + return new CElementBinOperator(TypeElement::frac); + } + else if (wsToken == L"div") + { + return new CElementBinOperator(TypeElement::div); + } + else if (wsToken == L"oplus") + { + return new CElementBinOperator(TypeElement::oplus); + } + else if (wsToken == L"ominus") + { + return new CElementBinOperator(TypeElement::ominus); + } + else if (wsToken == L"odot") + { + return new CElementBinOperator(TypeElement::odot); + } + else if (wsToken == L"otimes") + { + return new CElementBinOperator(TypeElement::otimes); + } + else if (wsToken == L"odivide") + { + return new CElementBinOperator(TypeElement::odivide); + } + else if (wsToken == L"circ") + { + return new CElementBinOperator(TypeElement::circ); + } + else if (wsToken == L"wideslash") + { + return new CElementBinOperator(TypeElement::wideslash); + } + else if (wsToken == L"widebslash") + { + return new CElementBinOperator(TypeElement::widebslash); + } + //brace + else if(L"{" == wsToken) return new CElementBracket(TypeElement::brace); +// else if(L"(" == wsToken) return TypeElement::round; +// else if(L"[" == wsToken) return TypeElement::square; +// else if(L"ldbracket" == wsToken) return TypeElement::ldbracket; +// else if(L"lbrace" == wsToken) return TypeElement::lbrace; +// else if(L"langle" == wsToken) return TypeElement::langle; +// else if(L"lceil" == wsToken) return TypeElement::lceil; +// else if(L"lfloor" == wsToken) return TypeElement::lfloor; +// else if(L"lline" == wsToken) return TypeElement::lline; +// else if(L"ldline" == wsToken) return TypeElement::ldline; + else if(CElementString::IsDigit(wsToken)) return new CElementString(wsToken); + else return nullptr; + } + void CElement::SetAttribute(const std::vector arAttr) + { + arElementAttributes = arAttr; + } +//class methods CElementString + CElementString::CElementString(const std::wstring& wsTokenString) + { + wsString = wsTokenString; + } + CElementString::~CElementString() + {} + void CElementString::SetString(const std::wstring& wsTokenString) + { + wsString = wsTokenString; + } + void CElementString::Pars(std::wstring::iterator &itStart, std::wstring::iterator &itEnd) + { + } + std::wstring CElementString::GetString() + { + return wsString; + } + bool CElementString::IsDigit(const std::wstring &wsToken) + { + for(char cOneElement: wsToken) + { + if(!isdigit(cOneElement)) return false; } return true; } - bool CStarMathPars::CheckScalable_NotScalableBracketLeft(const std::wstring &wsCheckToken) +//class methods CElementBinOperator + CElementBinOperator::CElementBinOperator(const TypeElement& enType) { - return(L"ldbracket" == wsCheckToken || L"lbrace" == wsCheckToken || L"langle" == wsCheckToken || L"lceil" == wsCheckToken || L"lfloor" == wsCheckToken || L"lline" == wsCheckToken || L"ldline" == wsCheckToken); + enTypeBinOp = enType; } - bool CStarMathPars::CheckScalable_NotScalableBracketRight(const std::wstring &wsCheckToken) + CElementBinOperator::~CElementBinOperator() { - return(L"rdbracket" == wsCheckToken || L"rbrace" == wsCheckToken || L"rangle" == wsCheckToken || L"rceil" == wsCheckToken || L"rfloor" == wsCheckToken || L"rline" == wsCheckToken || L"rdline" == wsCheckToken || L"right" == wsCheckToken); + delete pLeftArgument; + delete pRightArgument; } -////////////////Requires improvement - /*bool CStarMathPars::CheckUnarSign(std::wstring &wsCheckToken,CUnarySign& m_oUnarSign) + void CElementBinOperator::SetLeftArg(CElement *pElement) { - std::wstring wsTempValueUnarSign; - bool UnarSign = false; - for(int i = 0;i<2;i++) + pLeftArgument = pElement; + } + void CElementBinOperator::SetRightArg(CElement *pElement) + { + pRightArgument = pElement; + } + void CElementBinOperator::Pars(std::wstring::iterator &itStart, std::wstring::iterator &itEnd) + { + SetRightArg(CParseStarMathString::ParsElement(itStart,itEnd)); + } + void CElementBinOperator::SetTypeBinOP(const TypeElement &enType) + { + enTypeBinOp = enType; + } + bool CElementBinOperator::IsBinOperator(const TypeElement& enCheckType) + { + switch (enCheckType) { - if(wsCheckToken[i] == '+' || wsCheckToken[i] == '-') - { - wsTempValueUnarSign.push_back(wsCheckToken[i]); - UnarSign = true; - } - } - if(!wsTempValueUnarSign.empty() && UnarSign) - { - m_arParsLine.push_back(m_oUnarSign.GetUnarSign(wsTempValueUnarSign)); - wsCheckToken = wsCheckToken.substr(wsTempValueUnarSign.size()); - } - return UnarSign; - }*/ - bool CStarMathPars::CheckingTheNextElement(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd, bool (&func)(const std::wstring&)) - { - std::wstring::iterator itTempVal = itFirst; - bool bResult = func(GetElement(itFirst,itEnd)); - itFirst = itTempVal; - return bResult; - } - bool CStarMathPars::CheckBinOperator(const std::wstring &wsCheckToken) - { - return(L"*" ==wsCheckToken || L"/" == wsCheckToken || wsCheckToken == L"over" || wsCheckToken == L"cdot" || wsCheckToken == L"times" || wsCheckToken == L"div" || wsCheckToken == L"odot" || wsCheckToken == L"otimes" || wsCheckToken == L"odivide" || wsCheckToken == L"wideslash" || wsCheckToken == L"widebslash"); - } - bool CStarMathPars::CheckBinOperatorLowPriority(const std::wstring &wsCheckToken) - { - return (wsCheckToken == L"oplus" || wsCheckToken == L"ominus"|| wsCheckToken == L"circ"); - } - bool CStarMathPars::CheckPlusOrMinus(const std::wstring &wsCheckToken) - { - switch (wsCheckToken[0]) - { - case L'+': - return true; - case L'-': - return true; + case TypeElement::plus: + return true; + case TypeElement::minus: + return true; + case TypeElement::over: + return true; + case TypeElement::multipl: + return true; + case TypeElement::division: + return true; + case TypeElement::cdot: + return true; + case TypeElement::times: + return true; + case TypeElement::frac: + return true; + case TypeElement::div: + return true; + case TypeElement::oplus: + return true; + case TypeElement::ominus: + return true; + case TypeElement::odot: + return true; + case TypeElement::otimes: + return true; + case TypeElement::odivide: + return true; + case TypeElement::circ: + return true; + case TypeElement::wideslash: + return true; + case TypeElement::widebslash: + return true; default: - return false; + return false; } } - bool CStarMathPars::CheckOperator(const std::wstring &wsCheckToken) + bool CElementBinOperator::IsLowPriorityBinOp(const TypeElement &enType) { - return(wsCheckToken == L"lim" || wsCheckToken == L"sum"); - } - bool CStarMathPars::CheckIndex(const std::wstring &wsCheckToken) - { - return (wsCheckToken == L"_" || wsCheckToken == L"^" || L"lsup" == wsCheckToken || L"lsub" == wsCheckToken || L"csup" == wsCheckToken || L"csub" == wsCheckToken); - } - bool CStarMathPars::CheckIndexOp(const std::wstring &wsCheckToken) - { - return(L"from" == wsCheckToken || L"to" == wsCheckToken); - } - bool CStarMathPars::CheckBracketOpen(const std::wstring& wsCheckToken) - { - switch (wsCheckToken[0]) { - case '{': - return true; - case '(': - return true; - case '[': - return true; - default: - return false; - } - } - bool CStarMathPars::CheckBracketClose(const std::wstring& wsCheckToken) - { - switch (wsCheckToken[0]) {; - case '}': - return true; - case ')': - return true; - case ']': - return true; - default: - return false; - } - } - bool CStarMathPars::CheckTopAttribute(const std::wstring& wsCheckToken) - { - return(L"acute" == wsCheckToken || L"breve" == wsCheckToken || L"dot" == wsCheckToken || L"dddot" == wsCheckToken || L"vec" == wsCheckToken || L"tilde" == wsCheckToken || L"check" == wsCheckToken || L"grave" == wsCheckToken || L"circle" == wsCheckToken || L"ddot" == wsCheckToken || L"bar" == wsCheckToken || L"harpoon" == wsCheckToken || L"hat" == wsCheckToken || L"widevec" == wsCheckToken || L"widetilde" == wsCheckToken || L"overline" == wsCheckToken || L"overstrike" == wsCheckToken || L"wideharpoon" == wsCheckToken || L"widehat" == wsCheckToken || L"underline" == wsCheckToken); - } - bool CStarMathPars::CheckPropertiesAttribute(const std::wstring& wsCheckToken) - { - return(L"ital" == wsCheckToken || L"bold" == wsCheckToken || L"phantom" == wsCheckToken); - } - bool CStarMathPars::CheckColorAttribute(const std::wstring &wsCheckToken) - { - return (L"violet" == wsCheckToken || L"black" == wsCheckToken || L"green" == wsCheckToken || L"aqua" == wsCheckToken || L"yellow" == wsCheckToken || L"lime" == wsCheckToken || L"navy" == wsCheckToken || L"purple" == wsCheckToken || L"teal" == wsCheckToken || L"blue" == wsCheckToken || L"red" == wsCheckToken || L"fuchsia" == wsCheckToken || L"gray" == wsCheckToken || L"maroon" == wsCheckToken || L"olive" == wsCheckToken || L"silver" == wsCheckToken || L"coral" == wsCheckToken || L"midnightblue" == wsCheckToken || L"crimson" == wsCheckToken || L"violet" == wsCheckToken); - } - bool CStarMathPars::CheckSpecialCharacter(const std::wstring &wsCheckToken) - { - return (L"mline" == wsCheckToken || L"#" == wsCheckToken || L"##" == wsCheckToken); - } - bool CStarMathPars::CheckSpecialOperation(const std::wstring &wsCheckToken) - { - return(L"intersection" == wsCheckToken || L"union" == wsCheckToken || L"setminus" == wsCheckToken || L"setquoyient" == wsCheckToken || L"subseteq" == wsCheckToken || L"subset" == wsCheckToken || L"supset" == wsCheckToken || L"supseteq" == wsCheckToken || L"nsubset" == wsCheckToken || L"nsupseteq" == wsCheckToken || L"nsupset" == wsCheckToken || L"nsubseteq" == wsCheckToken || L"in" == wsCheckToken || L"notin" == wsCheckToken || L"owns" == wsCheckToken); - } - bool CStarMathPars::CheckSpecialConnection(const std::wstring &wsCheckToken) - { - return(L"approx" == wsCheckToken || L"sim" == wsCheckToken || L"simeq" == wsCheckToken || L"equiv" == wsCheckToken || L"prop" == wsCheckToken || L"parallel" == wsCheckToken || L"ortho" == wsCheckToken || L"divides" == wsCheckToken || L"ndivides" == wsCheckToken || L"toward" == wsCheckToken || L"transl" == wsCheckToken || L"transr" == wsCheckToken || L"def" == wsCheckToken || L"=" == wsCheckToken || L"<>" == wsCheckToken || L"<" == wsCheckToken || L"<=" == wsCheckToken || L"leslant" == wsCheckToken || L">" == wsCheckToken || L">=" == wsCheckToken || L"geslant" == wsCheckToken || L"<<" == wsCheckToken || L">>" == wsCheckToken || L"prec" == wsCheckToken || L"succ" == wsCheckToken || L"preccurlyeq" == wsCheckToken || L"succcurlyeq" == wsCheckToken || L"precsim" == wsCheckToken || L"succsim" == wsCheckToken || L"nprec" == wsCheckToken || L"nsucc" == wsCheckToken || L"dlarrow" == wsCheckToken || L"dlrarrow" == wsCheckToken || L"drarrow" == wsCheckToken); - } - std::vector CStarMathPars::GetVector() - { - return m_arParsLine; - } - bool CStarMathPars::CheckFunction(const std::wstring &wsCheckToken) - { - return(L"sin" == wsCheckToken || L"cos" == wsCheckToken || L"ln" == wsCheckToken || L"tan" == wsCheckToken || L"cot" == wsCheckToken || L"sinh" == wsCheckToken || L"cosh" == wsCheckToken || L"tanh" == wsCheckToken || L"coth" == wsCheckToken || L"arcsin" == wsCheckToken || L"arccos" == wsCheckToken || L"arctan" == wsCheckToken || L"arccot" == wsCheckToken || L"arsinh" == wsCheckToken || L"arcosh" == wsCheckToken || L"artanh" == wsCheckToken || L"arcoth" == wsCheckToken || L"abs" == wsCheckToken || L"fact" == wsCheckToken || L"sqrt" == wsCheckToken || L"nroot" == wsCheckToken); - } - bool CStarMathPars::CheckOperation(const std::wstring &wsCheckToken) - { - return(L"intersection" == wsCheckToken || L"union" == wsCheckToken || L"setminus" == wsCheckToken || L"setquoytient" == wsCheckToken || L"subseteq" == wsCheckToken || L"subset" == wsCheckToken); - } - bool CStarMathPars::CheckMatrix(const std::wstring &wsCheckToken) - { - return (L"stack" == wsCheckToken || L"matrix" == wsCheckToken || L"binom" == wsCheckToken); - } -//Class methods CNumber - CNumber::CNumber() - { - } - CNumber::CNumber(const std::wstring &wsValue) - { - this->m_wsValueNumber = wsValue; - } - CNumber::~CNumber() - { - } - - std::wstring CNumber::GetValue() - { - return m_wsValueNumber; - } - TypeElement CNumber::GetType() - { - return Number; - } -//Class methods CUnarySign - CUnarySign* CUnarySign::GetUnarSign(const std::wstring& wsUnarToken) - { - CUnarySign* oSign = new CUnarySign; - oSign->m_wsUnar = wsUnarToken; - return oSign; - } - - std::wstring CUnarySign::GetValue() - { - return m_wsUnar; - } - TypeElement CUnarySign::GetType() - { - return m_enUnarType; - } - CUnarySign::CUnarySign() - {} - CUnarySign::~CUnarySign() - {} -//Class methods CBinaryOperator - CBinaryOperator::CBinaryOperator() - { - oRightArg = nullptr; - } - CBinaryOperator::CBinaryOperator(const std::wstring& wsToken) - { - if(wsToken == L"+") - { - enTypeBinOp = plus; - } - else if(wsToken == L"-") - { - enTypeBinOp = minus; - } - else if(wsToken == L"*") - { - enTypeBinOp = multipl; - } - else if(wsToken == L"/") - { - enTypeBinOp = division; - } - else if(wsToken == L"over") - { - enTypeBinOp = over; - } - else if(wsToken == L"cdot") - { - enTypeBinOp = cdot; - } - else if(wsToken == L"times") - { - enTypeBinOp = times; - } - else if(wsToken == L"frac") - { - enTypeBinOp = frac; - } - else if(wsToken == L"div") - { - enTypeBinOp = div; - } - else if(wsToken == L"oplus") - { - enTypeBinOp = oplus; - } - else if(wsToken == L"ominus") - { - enTypeBinOp = ominus; - } - else if(wsToken == L"odot") - { - enTypeBinOp = odot; - } - else if(wsToken == L"otimes") + switch (enType) { - enTypeBinOp = otimes; + case TypeElement::plus: + return true; + case TypeElement::minus: + return true; + case TypeElement::oplus: + return true; + case TypeElement::ominus: + return true; + case TypeElement::circ: + return true; + default: + return false; } - else if(wsToken == L"odivide") - { - enTypeBinOp = odivide; - } - else if(wsToken == L"circ") - { - enTypeBinOp = circ; - } - else if(wsToken == L"wideslash") - { - enTypeBinOp = wideslash; - } - else if(wsToken == L"widebslash") - { - enTypeBinOp = widebslash; - } - oRightArg = nullptr; - } - CBinaryOperator::~CBinaryOperator() - { - delete oRightArg; } - TypeElement CBinaryOperator::GetType() + bool CElementBinOperator::IsHighPriorityBinOp(const TypeElement &enType) { - return BinOperator; - } - std::wstring CBinaryOperator::GetValue() - { - return {}; - } - TypeBinOperator CBinaryOperator::GetTypeBin() - { - return enTypeBinOp; - } - void CBinaryOperator::SetRightArg(CElement *oArgument) - { - oRightArg = oArgument; - } - void CBinaryOperator::SetTypeBin(const TypeBinOperator &enType) - { - this->enTypeBinOp = enType; - } - CElement* CBinaryOperator::GetRightArg() - { - return oRightArg; - } - TypeElement CBinaryOperator::GetTypeRight() - { - return oRightArg->GetType(); - } -//Class methods COperator - COperator::COperator(): oFromValue(NULL),oToValue(NULL),oValueOp(NULL) - {} - COperator::COperator(const std::wstring& wsToken): oFromValue(NULL), oToValue(NULL), oValueOp(NULL) - { - if(wsToken== L"lim") + switch(enType) { - enTypeOp = lim; + case TypeElement::over: + return true; + default: + return false; } - else if(wsToken == L"sum") - { - enTypeOp = sum; - } - } - COperator::~COperator() - { - delete oFromValue; - delete oToValue; - delete oValueOp; - } - TypeElement COperator::GetType() - { - return Operator; - } - std::wstring COperator::GetValue() - { - return {}; - } - TypeOperator COperator::GetTypeOp() - { - return enTypeOp; - } - void COperator::SetFrom(CElement *oFrom) - { - oFromValue = oFrom; - } - void COperator::SetTo(CElement *oTo) - { - oToValue = oTo; - } - void COperator::SetValueOp(CElement *oValue) - { - oValueOp = oValue; - } - void COperator::SetTypeOp(const TypeOperator& enType) - { - enTypeOp = enType; - } - CElement* COperator::GetValueOp() - { - return oValueOp; - } - CElement* COperator::GetFrom() - { - return oFromValue; - } - CElement* COperator::GetTo() - { - return oToValue; - } -//Class methods CBracket - CBracket::CBracket() - {} - CBracket::CBracket(const std::vector& arValue,const std::wstring& wsCheckToken) - { - arBrecketVal = arValue; - if (L"{" == wsCheckToken) enTypeBracket =brace; - else if (L"(" == wsCheckToken) enTypeBracket = round; - else if (L"[" == wsCheckToken) enTypeBracket = square; - else if(wsCheckToken == L"ldbracket") - { - enTypeBracket = ldbracket; - } - else if(wsCheckToken == L"lbrace") - { - enTypeBracket = lbrace; - } - else if(wsCheckToken == L"langle") - { - enTypeBracket = langle; - } - else if(wsCheckToken == L"lceil") - { - enTypeBracket = lceil; - } - else if(wsCheckToken == L"lfloor") - { - enTypeBracket = lfloor; - } - else if(wsCheckToken == L"lline") - { - enTypeBracket = lline; - } - else if(wsCheckToken == L"ldline") - { - enTypeBracket = ldline; - } - } - CBracket::~CBracket() - { - for(CElement* ReleaseObject: arBrecketVal) - { - delete ReleaseObject; - } - } - TypeElement CBracket::GetType() - { - for(CElement* enTemp: arBrecketVal) - { - std::wcout<< enTemp->GetType() << std::endl; - } - return Bracket; - } - std::wstring CBracket::GetValue() - { - return {}; - } - void CBracket::SetScalable() - { - bScalable = true; - } - void CBracket::SetBracketVal(const std::vector &arBrecketValue) - { - arBrecketVal = arBrecketValue; } - void CBracket::SetTypeBracket(const std::wstring& wsCheckToken) +//class methods CElementBracket + CElementBracket::CElementBracket(const TypeElement& enType) { - if (L"{" == wsCheckToken) enTypeBracket = brace; - else if (L"(" == wsCheckToken) enTypeBracket = round; - else if (L"[" == wsCheckToken) enTypeBracket = square; - else if(wsCheckToken == L"ldbracket") - { - enTypeBracket = ldbracket; - } - else if(wsCheckToken == L"lbrace") - { - enTypeBracket = lbrace; - } - else if(wsCheckToken == L"langle") - { - enTypeBracket = langle; - } - else if(wsCheckToken == L"lceil") - { - enTypeBracket = lceil; - } - else if(wsCheckToken == L"lfloor") - { - enTypeBracket = lfloor; - } - else if(wsCheckToken == L"lline") - { - enTypeBracket = lline; - } - else if(wsCheckToken == L"ldline") - { - enTypeBracket = ldline; - } + enTypeBracket = enType; } -//Class methods CAttribute - CAttribute::CAttribute() + CElementBracket::~CElementBracket() { + for(CElement* pTemp:arBrecketValue) delete pTemp; } - CAttribute::CAttribute(const TypeAttributeTop &enType) + void CElementBracket::SetBracketValue(const std::vector &arValue) { - enTypeTop = enType; + arBrecketValue = arValue; } - CAttribute::~CAttribute() + bool CElementBracket::IsBracketClose(const std::wstring &wsToken) { + if(L"}" == wsToken) return true; + else if(L")" == wsToken) return true; + else if(L"]" == wsToken) return true; + else return false; } - void CAttribute::SetTypeAtt(const std::wstring& wsCheckToken) + //нужно поправить GetElement(беру его тут + в методе ParsElement) + void CElementBracket::Pars(std::wstring::iterator &itStart, std::wstring::iterator &itEnd) { - if(wsCheckToken == L"phantom") - { - bPhantom = true; - } - else if(wsCheckToken == L"bold") - { - bBold = true; - } - else if(wsCheckToken == L"ital") - { - bItal = true; - } - else if(wsCheckToken == L"black") - { - enTypeColor = black; - } - else if(wsCheckToken == L"green") - { - enTypeColor = green; - } - else if(wsCheckToken == L"aqua") - { - enTypeColor = aqua; - } - else if(wsCheckToken == L"yellow") - { - enTypeColor = yellow; - } - else if(wsCheckToken == L"lime") - { - enTypeColor = lime; - } - else if(wsCheckToken == L"navy") - { - enTypeColor = navy; - } - else if(wsCheckToken == L"purple") + std::wstring wsToken = CParseStarMathString::GetElement(itStart,itEnd) ; + while(L"right" != wsToken && !IsBracketClose(wsToken)) { - enTypeColor = purple; + arBrecketValue.push_back(CParseStarMathString::ParsElement(itStart,itEnd)); + wsToken = CParseStarMathString::GetElement(itStart,itEnd); } - else if(wsCheckToken == L"teal") - { - enTypeColor = teal; - } - else if(wsCheckToken == L"blue") - { - enTypeColor = blue; - } - else if(wsCheckToken == L"red") - { - enTypeColor = red; - } - else if(wsCheckToken == L"fuchsia") - { - enTypeColor = fuchsia; - } - else if(wsCheckToken == L"gray") - { - enTypeColor = gray; - } - else if(wsCheckToken == L"maroon") - { - enTypeColor = maroon; - } - else if(wsCheckToken == L"olive") - { - enTypeColor = olive; - } - else if(wsCheckToken == L"silver") - { - enTypeColor = silver; - } - else if(wsCheckToken == L"coral") - { - enTypeColor = coral; - } - else if(wsCheckToken == L"midnightblue") - { - enTypeColor = midnightblue; - } - else if(wsCheckToken == L"crimson") - { - enTypeColor = crimson; - } - else if(wsCheckToken == L"violet") - { - enTypeColor = violet; - } - else if(wsCheckToken == L"acute") - { - enTypeTop = acute; - } - else if(wsCheckToken == L"breve") - { - enTypeTop = breve; - } - else if(wsCheckToken == L"dot") - { - enTypeTop = dot; - } - else if(wsCheckToken == L"dddot") - { - enTypeTop = dddot; - } - else if(wsCheckToken == L"vec") - { - enTypeTop = vec; - } - else if(wsCheckToken == L"tilde") - { - enTypeTop = tilde; - } - else if(wsCheckToken == L"check") - { - enTypeTop = check; - } - else if(wsCheckToken == L"grave") - { - enTypeTop = grave; - } - else if(wsCheckToken == L"circle") - { - enTypeTop = circle; - } - else if(wsCheckToken == L"ddot") - { - enTypeTop = ddot; - } - else if(wsCheckToken == L"bar") - { - enTypeTop = bar; - } - else if(wsCheckToken == L"harpoon") - { - enTypeTop = harpoon; - } - else if(wsCheckToken == L"hat") - { - enTypeTop = hat; - } - else if(wsCheckToken == L"widevec") - { - enTypeTop = widevec; - } - else if(wsCheckToken == L"widetilde") - { - enTypeTop = widetilde; - } - else if(wsCheckToken == L"overline") - { - enTypeTop = overline; - } - else if(wsCheckToken == L"overstrike") - { - enTypeTop = overstrike; - } - else if(wsCheckToken == L"wideharpoon") - { - enTypeTop = wideharpoon; - } - else if(wsCheckToken == L"widehat") - { - enTypeTop = widehat; - } - else if(wsCheckToken == L"underline") - { - enTypeTop = underline; - } - } - TypeAttributeTop CAttribute::GetTypeAtt() - { - return enTypeTop; - } -//Class methods CElement - CElement::~CElement() - { - } - void CElement::SetAttribute(CAttribute* m_oCAttribute) - { - oCAttribute = m_oCAttribute; - } - TypeAttributeTop CElement::GetTypeAttribute() - { - return oCAttribute->GetTypeAtt(); - } -//Class methods CSpecial - CSpecialSymbol::CSpecialSymbol(const std::wstring& wsToken) - { - if(L"mline" == wsToken) enTypeSpecial = mline; - else if(L"#" == wsToken) enTypeSpecial = grid; - else if(L"##" == wsToken) enTypeSpecial = dlgrid; - else if(L"intersection" == wsToken) enTypeSpecial = intersection; - else if(L"union" == wsToken) enTypeSpecial = Union; - else if(L"setminus" == wsToken) enTypeSpecial = setminus; - else if(L"setquoyient" == wsToken) enTypeSpecial = setquoyient; - else if(L"subseteg" == wsToken) enTypeSpecial = subseteq; - else if(L"subset" == wsToken) enTypeSpecial = subset; - else if(L"supset" == wsToken) enTypeSpecial = supset; - else if(L"supseteq" == wsToken) enTypeSpecial = supseteq; - else if(L"nsubset" == wsToken) enTypeSpecial = nsubset; - else if(L"nsubseteq" == wsToken) enTypeSpecial = nsubseteq; - else if(L"nsupseteq" == wsToken) enTypeSpecial = nsupseteq; - else if(L"nsupset" == wsToken) enTypeSpecial = nsupset; - else if(L"in" == wsToken) enTypeSpecial = in; - else if(L"notin" == wsToken) enTypeSpecial = notin; - else if(L"owns" == wsToken) enTypeSpecial = owns; - else if(L"approx" == wsToken) enTypeSpecial = approx; - else if(L"sim" == wsToken) enTypeSpecial = sim; - else if(L"simeq" == wsToken) enTypeSpecial = simeq; - else if(L"equiv" == wsToken) enTypeSpecial = equiv; - else if(L"prop" == wsToken) enTypeSpecial = prop; - else if(L"parallel" == wsToken) enTypeSpecial = parallel; - else if(L"ortho" == wsToken) enTypeSpecial = ortho; - else if(L"divides" == wsToken) enTypeSpecial = divides; - else if(L"ndivides" == wsToken) enTypeSpecial = ndivides; - else if(L"toward" == wsToken) enTypeSpecial = toward; - else if(L"transl" == wsToken) enTypeSpecial = transl; - else if(L"transr" == wsToken) enTypeSpecial = transr; - else if(L"def" == wsToken) enTypeSpecial = def; - else if(L"=" == wsToken) enTypeSpecial = equals; - else if(L"<>" == wsToken) enTypeSpecial = notequals; - else if(L"<" == wsToken) enTypeSpecial = learrow; - else if(L"<=" == wsToken) enTypeSpecial = learrowequals; - else if(L"leslant" == wsToken) enTypeSpecial = leslant; - else if(L">" == wsToken) enTypeSpecial = riarrow; - else if(L">=" == wsToken) enTypeSpecial = riarrowequals; - else if(L"geslant" == wsToken) enTypeSpecial = geslant; - else if(L"<<" == wsToken) enTypeSpecial = dllearrow; - else if(L">>" == wsToken) enTypeSpecial = dlriarrow; - else if(L"prec" == wsToken) enTypeSpecial = prec; - else if(L"succ" == wsToken) enTypeSpecial = succ; - else if(L"preccurlyeq" == wsToken) enTypeSpecial = preccurlyeq; - else if(L"succcurlyeq" == wsToken) enTypeSpecial = succcurlyeq; - else if(L"precsim" == wsToken) enTypeSpecial = precsim; - else if(L"succsim" == wsToken) enTypeSpecial = succsim; - else if(L"nprec" == wsToken) enTypeSpecial = nprec; - else if(L"nsucc" == wsToken) enTypeSpecial = nsucc; - else if(L"dlarrow" == wsToken) enTypeSpecial = dlarrow; - else if(L"dlrarrow" == wsToken) enTypeSpecial = dlrarrow; - else if(L"drarrow" == wsToken) enTypeSpecial = drarrow; - SetAttribute(nullptr); - } - CSpecialSymbol::~CSpecialSymbol() - {} - std::wstring CSpecialSymbol::GetValue() - { - return {}; - } - TypeElement CSpecialSymbol::GetType() - { - return SpecialSymbol; - } -//class methods CFunction - CFunction::CFunction() - {} - CFunction::~CFunction() - { - } - std::wstring CFunction::GetValue() - { - return L""; - } - TypeElement CFunction::GetType() - { - return Function; - } - TypeFunction CFunction::GetTypeFun() - { - return enTypeFun; - } - void CFunction::SetTypeFunction(const std::wstring &wsCheckToken) - { - if(L"sin" == wsCheckToken) enTypeFun = sin; - else if(L"abs" == wsCheckToken) enTypeFun = abs; - else if(L"fact" == wsCheckToken) enTypeFun = fact; - else if(L"sqrt" == wsCheckToken) enTypeFun = sqrt; - else if(L"cos" == wsCheckToken) enTypeFun = cos; - else if(L"tan" == wsCheckToken) enTypeFun = tan; - else if(L"cot" == wsCheckToken) enTypeFun = cot; - else if(L"sinh" == wsCheckToken) enTypeFun = sinh; - else if(L"cosh" == wsCheckToken) enTypeFun = cosh; - else if(L"tanh" == wsCheckToken) enTypeFun = tanh; - else if(L"coth" == wsCheckToken) enTypeFun = coth; - else if(L"arcsin" == wsCheckToken) enTypeFun = arcsin; - else if(L"arccos" == wsCheckToken) enTypeFun = arccos; - else if(L"arctan" == wsCheckToken) enTypeFun = arctan; - else if(L"arccot" == wsCheckToken) enTypeFun = arccot; - else if(L"arsinh" == wsCheckToken) enTypeFun = arsinh; - else if(L"arcosh" == wsCheckToken) enTypeFun = arcosh; - else if(L"artanh" == wsCheckToken) enTypeFun = artanh; - else if(L"arcoth" == wsCheckToken) enTypeFun = arcoth; - else if(L"ln" == wsCheckToken) enTypeFun = ln; - } -//class methods CArgumentContainer - CArgumentContainer::CArgumentContainer() - { - oArgument = nullptr; - } - CArgumentContainer::~CArgumentContainer() - { - delete oArgument; - } - std::wstring CArgumentContainer::GetValue() - { - return L""; - } - TypeElement CArgumentContainer::GetType() - { - return TwoArgumentContainer; - } - void CArgumentContainer::SetArgument(CElement *oValue) - { - oArgument = oValue; - } - CElement* CArgumentContainer::GetArgument() - { - return oArgument; - } -//class methods CIndex - CIndex::CIndex(const std::wstring& wsToken) - { - if(L"^" == wsToken) enTypeIn = upper; - else if(L"_" == wsToken) enTypeIn = lower; - else if(L"lsup" == wsToken) enTypeIn = lsup; - else if(L"lsub" == wsToken) enTypeIn = lsub; - else if(L"csup" == wsToken) enTypeIn = csup; - else if(L"csub" == wsToken) enTypeIn = csub; - SetAttribute(nullptr); - } - CIndex::~CIndex() - { - delete oIndex; - } - std::wstring CIndex::GetValue() - { - return {}; - } - TypeElement CIndex::GetType() - { - return Index; - } - void CIndex::SetIndex(CElement *oValueIndex) - { - oIndex = oValueIndex; } -//class methods CMatrix - CMatrix::CMatrix(const std::wstring& wsToken) - { - if (L"binom" == wsToken) enTypeMatrix = binom; - else if(L"stack" == wsToken) enTypeMatrix = stack; - else if(L"matrix" == wsToken) enTypeMatrix = matrix; - } - CMatrix::~CMatrix() - {} - std::wstring CMatrix::GetValue() - { - return {}; - } - TypeElement CMatrix::GetType() - { - return Matrix; - } } - diff --git a/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.h b/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.h index 1d594a5356..613a5caf88 100644 --- a/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.h +++ b/OdfFile/Reader/Converter/StarMath2OOXML/cstarmathpars.h @@ -11,203 +11,82 @@ namespace StarMath class CAttribute { public: - CAttribute(); - CAttribute(const TypeAttributeTop& enType); - virtual ~CAttribute(); - void SetTypeAtt(const std::wstring& wsCheckToken); - TypeAttributeTop GetTypeAtt(); + CAttribute(const TypeElement& enType); + ~CAttribute(); + static TypeElement IsAttribute(const std::wstring& wsToken); + TypeElement GetType(); private: - TypeAttributeTop enTypeTop{noneTop}; - TypeAttributeColor enTypeColor{noneColor}; - bool bBold{false}; - bool bItal{false}; - bool bPhantom{false}; + TypeElement enTypeAttr; }; - class CElement { public: + CElement(); virtual ~CElement(); - virtual std::wstring GetValue() = 0; - virtual TypeElement GetType() = 0; - void SetAttribute(CAttribute* m_oCAttribute); - TypeAttributeTop GetTypeAttribute(); + virtual void Pars(std::wstring::iterator& itStart,std::wstring::iterator& itEnd) = 0; + //принимает подтип (over, frac и т.д) и создает нужный нам класс(внутри уже идет проверка по классам) + static CElement* CreateElement(const std::wstring& wsToken); + //static TypeElement GetTypeElement(const std::wstring& wsToken); + void SetAttribute(const std::vector arAttr); private: - CAttribute* oCAttribute; - }; - class CSpecialSymbol: public CElement - { - public: - CSpecialSymbol(const std::wstring& wsToken); - virtual ~CSpecialSymbol(); - std::wstring GetValue() override; - TypeElement GetType() override; - private: - TypeSymbol enTypeSpecial; - }; - class CNumber: public CElement - { - public: - CNumber(); - CNumber(const std::wstring& wsValue); - virtual ~CNumber(); - std::wstring GetValue() override; - TypeElement GetType() override ; - private: - std::wstring m_wsValueNumber; + std::vector arElementAttributes; }; - class CUnarySign: public CElement + class CElementString: public CElement { public: - CUnarySign(); - ~CUnarySign(); - std::wstring GetValue() override; - TypeElement GetType() override; - CUnarySign* GetUnarSign(const std::wstring& wsUnarToken); + CElementString(const std::wstring& wsTokenString); + virtual ~CElementString(); + void SetString(const std::wstring& wsTokenString); + void Pars(std::wstring::iterator& itStart,std::wstring::iterator& itEnd) override; + std::wstring GetString(); + static bool IsDigit(const std::wstring& wsCheckToken); private: - std::wstring m_wsUnar; - TypeElement m_enUnarType = UnarSign; + std::wstring wsString; }; - class CArgumentContainer: public CElement + class CElementBinOperator: public CElement { public: - CArgumentContainer(); - virtual ~CArgumentContainer(); - std::wstring GetValue() override; - TypeElement GetType() override; - void SetArgument(CElement* oValue); - CElement* GetArgument(); - private: - CElement* oArgument; - }; - - class CBinaryOperator: public CArgumentContainer - { - public: - CBinaryOperator(); - CBinaryOperator(const std::wstring& wsToken); - virtual ~CBinaryOperator(); - std::wstring GetValue() override; - TypeElement GetType() override; - TypeBinOperator GetTypeBin(); - void SetRightArg(CElement* oArgument); - void SetTypeBin(const TypeBinOperator& enType); + CElementBinOperator(const TypeElement& enType); + virtual ~CElementBinOperator(); + void Pars(std::wstring::iterator& itStart,std::wstring::iterator& itEnd) override; + void SetLeftArg(CElement* pElement); + void SetRightArg(CElement* pElement); + void SetTypeBinOP(const TypeElement& enType); CElement* GetRightArg(); - TypeElement GetTypeRight(); + CElement* GetLeftArg(); + static bool IsBinOperator(const TypeElement& enCheckType); private: - CElement* oRightArg; - TypeBinOperator enTypeBinOp; + bool IsLowPriorityBinOp(const TypeElement& enType); + bool IsHighPriorityBinOp(const TypeElement& enType); + CElement* pLeftArgument; + CElement* pRightArgument; + TypeElement enTypeBinOp; }; - class COperator: public CElement + + class CElementBracket: public CElement { public: - COperator(); - COperator(const std::wstring& wsToken); - virtual ~COperator(); - std::wstring GetValue() override; - TypeElement GetType() override; - TypeOperator GetTypeOp(); - void SetTypeOp(const TypeOperator& enType); - void SetFrom(CElement* oFrom); - void SetTo(CElement* oTo); - void SetValueOp(CElement* oValue); - CElement* GetValueOp(); - CElement* GetFrom(); - CElement* GetTo(); + CElementBracket(const TypeElement& enType); + virtual ~CElementBracket(); + void SetBracketValue(const std::vector& arValue); + void Pars(std::wstring::iterator& itStart,std::wstring::iterator& itEnd) override; private: - TypeOperator enTypeOp; - CElement* oFromValue{nullptr}; - CElement* oToValue{nullptr}; - CElement* oValueOp{nullptr}; + static bool IsBracketClose(const std::wstring& wsToken); + TypeElement enTypeBracket; + std::vector arBrecketValue; }; - class CBracket: public CElement + + class CParseStarMathString { public: - CBracket(); - CBracket(const std::vector& arValue,const std::wstring& wsCheckToken); - virtual ~CBracket(); - std::wstring GetValue() override; - TypeElement GetType() override; - void SetScalable(); - void SetBracketVal(const std::vector& arBrecketValue); - void SetTypeBracket(const std::wstring& wsCheckToken); + std::vector Parse(std::wstring& wsParseString); + static CElement* ParsElement(std::wstring::iterator& itStart, std::wstring::iterator& itEnd); + static std::wstring GetElement(std::wstring::iterator& itStart,std::wstring::iterator& itEnd); + static bool CheckingTheNextElement(std::wstring::iterator& itStart,std::wstring::iterator& itEnd, bool (&func)(const std::wstring&)); private: - bool bScalable{false}; - TypeBracket enTypeBracket; - std::vector arBrecketVal; - }; - class CFunction: public CArgumentContainer - { - public: - CFunction(); - virtual ~CFunction(); - std::wstring GetValue() override; - TypeElement GetType() override; - TypeFunction GetTypeFun(); - void SetTypeFunction(const std::wstring& wsCheckToken); - private: - TypeFunction enTypeFun; - }; - class CIndex: public CArgumentContainer - { - public: - CIndex(const std::wstring& wsToken); - virtual ~CIndex(); - std::wstring GetValue() override; - TypeElement GetType() override; - void SetIndex(CElement* oValueIndex); - CElement* GetIndex(); - private: - TypeIndex enTypeIn; - CElement* oIndex; - }; - class CMatrix: public CArgumentContainer - { - public: - CMatrix(const std::wstring& wsToken); - virtual ~CMatrix(); - std::wstring GetValue() override; - TypeElement GetType() override; - private: - TypeMatrix enTypeMatrix; - }; - class CStarMathPars - { - public: - CStarMathPars(); - virtual ~CStarMathPars(); - std::vector GetVector(); - void Pars(std::wstring& wsStarMathLine); - std::wstring GetElement(std::wstring::iterator& itFirst,std::wstring::iterator& itEnd); - CElement* ParsElement(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd, std::vector& arParsLine); - CElement* ReadWithoutBrackets(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd,std::vector& arParsLine); - bool CheckDigit(const std::wstring& wsCheckToken); - //bool CheckUnarSign(std::wstring& wsCheckToken,CUnarySign& oUnarSign); - static bool CheckBinOperator(const std::wstring& wsCheckToken); - static bool CheckBinOperatorLowPriority(const std::wstring& wsCheckToken); - static bool CheckPlusOrMinus(const std::wstring& wsCheckToken); - bool CheckOperator(const std::wstring& wsCheckToken); - static bool CheckIndex(const std::wstring& wsCheckToken); - bool CheckIndexOp(const std::wstring& wsCheckToken); - bool CheckBracketOpen(const std::wstring& wsCheckToken); - static bool CheckBracketClose(const std::wstring& wsCheckToken); - static bool CheckScalable_NotScalableBracketLeft(const std::wstring& wsCheckToken); - static bool CheckScalable_NotScalableBracketRight(const std::wstring& wsCheckToken); - bool CheckTopAttribute(const std::wstring& wsCheckToken); - bool CheckPropertiesAttribute(const std::wstring& wsCheckToken); - static bool CheckColorAttribute(const std::wstring& wsCheckToken); - bool CheckSpecialCharacter(const std::wstring& wsCheckToken); - bool CheckSpecialOperation(const std::wstring& wsCheckToken);//doing first - bool CheckSpecialConnection(const std::wstring& wsCheckToken);// doint first - bool CheckingTheNextElement(std::wstring::iterator& itFirst, std::wstring::iterator& itEnd,bool (&func)(const std::wstring& wsCheckToken)); - bool CheckFunction(const std::wstring& wsCheckToken); - bool CheckOperation(const std::wstring& wsCheckToken); - bool CheckMatrix(const std::wstring& wsCheckToken); - void PrintAr(); - private: - std::vector m_arParsLine; + std::vector arEquation; }; } diff --git a/OdfFile/Reader/Converter/StarMath2OOXML/typeselements.h b/OdfFile/Reader/Converter/StarMath2OOXML/typeselements.h index 80e0cf7056..8cb8406ea5 100644 --- a/OdfFile/Reader/Converter/StarMath2OOXML/typeselements.h +++ b/OdfFile/Reader/Converter/StarMath2OOXML/typeselements.h @@ -2,8 +2,10 @@ #define TYPESELEMENTS_H namespace StarMath { -enum TypeElement{ - Number, +enum class TypeElement{ + undefine, + //global + String, BinOperator, Operator, Bracket, @@ -15,9 +17,7 @@ enum TypeElement{ Operation, Index, Matrix, -}; -enum TypeBinOperator -{ + //binoop cdot, times, over, @@ -35,14 +35,10 @@ enum TypeBinOperator circ, wideslash, widebslash, -}; -enum TypeOperator -{ + //op lim, sum, -}; -enum TypeBracket -{ + //brace brace, round, square, @@ -53,10 +49,10 @@ enum TypeBracket lfloor, lline, ldline, -}; -enum TypeAttributeTop -{ - noneTop, + //attribute + ital, + bold, + //top element acute, breve, dot, @@ -77,10 +73,7 @@ enum TypeAttributeTop wideharpoon, widehat, underline,//top elements -}; -enum TypeAttributeColor -{ - noneColor, + color, black, green, aqua, @@ -99,10 +92,14 @@ enum TypeAttributeColor coral, midnightblue, crimson, - violet,//color(without rgb and hex) -}; -enum TypeSymbol -{ + violet, + orange, + seagreen, + hotpink, + orangered, + indigo, + lavender, + //color(without rgb and hex) mline, grid, dlgrid, @@ -155,9 +152,27 @@ enum TypeSymbol dlarrow, dlrarrow, drarrow, -}; -enum TypeFunction -{ + emptyset, + aleph, + setN, + setZ, + setQ, + setR, + setC, + infinity, + partial, + nabla, + exists, + notexists, + forall, + hbar, + lambdabar, + Re, + Im, + wp, + laplace, + fourier, + backepsilon, abs, fact, sqrt, @@ -181,18 +196,12 @@ enum TypeFunction ln, exp, log, -}; -enum TypeIndex -{ upper, lower, lsup, lsub, csup, csub, -}; -enum TypeMatrix -{ binom, stack, matrix,