| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #ifndef LUIDL_DISTRIB_HXX |
| #define LUIDL_DISTRIB_HXX |
| |
| |
| |
| // USED SERVICES |
| // BASE CLASSES |
| #include <s2_luidl/tokrecv.hxx> |
| #include <s2_dsapi/tokrecv.hxx> |
| #include <s2_luidl/tokproct.hxx> |
| // COMPONENTS |
| // PARAMETERS |
| |
| |
| class ParserInfo; |
| |
| namespace ary |
| { |
| class Repository; |
| |
| namespace doc |
| { |
| class OldIdlDocu; |
| } // namespace inf |
| } // namespace ary) |
| |
| |
| |
| namespace csi |
| { |
| namespace dsapi |
| { |
| class Token_Receiver; |
| class SapiDocu_PE; |
| } |
| |
| |
| |
| namespace uidl |
| { |
| |
| |
| typedef std::vector< DYN Token * > TokenQueue; |
| typedef TokenQueue::iterator TokenIterator; |
| |
| class TokenParser_Uidl; |
| class UnoIDL_PE; |
| class Token; |
| |
| |
| class TokenDistributor : private TokenProcessing_Types |
| |
| { |
| public: |
| TokenDistributor( |
| ary::Repository & io_rRepository, |
| ParserInfo & io_rParserInfo ); |
| void SetTokenProvider( |
| TokenParser_Uidl & io_rTokenSource ); |
| void SetTopParseEnvironment( |
| UnoIDL_PE & io_pTopParseEnvironment ); |
| ~TokenDistributor(); |
| |
| |
| void Reset() { aDocumentation.Reset(); } |
| /** calls pTokenSource->GetNextToken() and checks the incoming tokens, until a |
| usable token is found. This token will be forwarded to |
| pTopParseEnv; |
| */ |
| void TradeToken(); |
| |
| csi::uidl::Token_Receiver & |
| CodeTokens_Receiver(); |
| csi::dsapi::Token_Receiver & |
| DocuTokens_Receiver(); |
| |
| /** Used from PE_File, if there is a docu to get without |
| an environment to push (this is the case for modules). |
| */ |
| DYN ary::doc::OldIdlDocu * |
| ReleaseLastParsedDocu() |
| { return aDocumentation.ReleaseLastParsedDocu(); } |
| |
| /** Used from PE_File, if the term "published" was parsed. |
| The next opened parse environment will be set to be published |
| (call ->UnoIDL_PE::SetPublished()). |
| */ |
| void Set_PublishedOn() |
| { aProcessingData.Set_PublishedOn(); } |
| |
| |
| private: |
| class Documentation; |
| class ProcessingData; |
| friend class ProcessingData; |
| |
| class ProcessingData : public csi::uidl::Token_Receiver, |
| private TokenProcessing_Types |
| { |
| public: |
| ProcessingData( |
| ary::Repository & io_rRepository, |
| Documentation & i_rDocuProcessor, |
| ParserInfo & io_rParserInfo ); |
| ~ProcessingData(); |
| void SetTopParseEnvironment( |
| UnoIDL_PE & io_pTopParseEnvironment ); |
| |
| |
| /** is called from pTokenSource before finishing a ::TokenParse2::GetNextToken() |
| call and passes the just parsed token to this class. |
| */ |
| virtual void Receive( |
| DYN csi::uidl::Token & |
| let_drToken ); |
| virtual void Increment_CurLine(); |
| |
| void ProcessCurToken(); |
| |
| UnoIDL_PE & CurEnvironment() const; |
| bool NextTokenExists() const; |
| void Set_PublishedOn() |
| { bPublishedRecentlyOn = true; } |
| |
| private: |
| typedef uintt TokenQ_Position; |
| typedef std::pair< UnoIDL_PE *, TokenQ_Position > EnvironmentInfo; |
| typedef std::vector< EnvironmentInfo > EnvironmentStack; |
| |
| void AcknowledgeResult(); |
| const csi::uidl::Token & |
| CurToken() const; |
| UnoIDL_PE & CurEnv() const; |
| UnoIDL_PE & PushEnv() const; |
| uintt CurTokenPosition() const; |
| uintt CurEnv_TriedTokenPosition() const; |
| void DecrementTryCount(); |
| |
| EnvironmentStack aEnvironments; |
| TokenQueue aTokenQueue; |
| TokenIterator itCurToken; |
| TokenProcessing_Result |
| aCurResult; |
| uintt nTryCount; |
| bool bFinished; |
| ary::Repository & |
| rRepository; |
| ParserInfo & rParserInfo; |
| Documentation * pDocuProcessor; |
| bool bPublishedRecentlyOn; |
| }; |
| |
| class Documentation : public csi::dsapi::Token_Receiver |
| { |
| public: |
| Documentation( |
| ParserInfo & io_rParserInfo); |
| ~Documentation(); |
| |
| void Reset() { bIsPassedFirstDocu = false; } |
| |
| virtual void Receive( |
| DYN csi::dsapi::Token & |
| let_drToken ); |
| virtual void Increment_CurLine(); |
| DYN ary::doc::OldIdlDocu * |
| ReleaseLastParsedDocu() |
| { return pMostRecentDocu.Release(); } |
| private: |
| Dyn<csi::dsapi::SapiDocu_PE> |
| pDocuParseEnv; |
| ParserInfo & rParserInfo; |
| Dyn<ary::doc::OldIdlDocu> |
| pMostRecentDocu; |
| bool bIsPassedFirstDocu; |
| }; |
| |
| // DATA |
| TokenParser_Uidl * pTokenSource; |
| Documentation aDocumentation; |
| ProcessingData aProcessingData; |
| }; |
| |
| |
| |
| // IMPLEMENTATION |
| |
| inline void |
| TokenDistributor::SetTokenProvider( TokenParser_Uidl & io_rTokenSource ) |
| { pTokenSource = &io_rTokenSource; } |
| |
| inline void |
| TokenDistributor::SetTopParseEnvironment( UnoIDL_PE & io_pTopParseEnvironment ) |
| { aProcessingData.SetTopParseEnvironment(io_pTopParseEnvironment); } |
| |
| inline csi::uidl::Token_Receiver & |
| TokenDistributor::CodeTokens_Receiver() |
| { return aProcessingData; } |
| |
| inline csi::dsapi::Token_Receiver & |
| TokenDistributor::DocuTokens_Receiver() |
| { return aDocumentation; } |
| |
| inline const csi::uidl::Token & |
| TokenDistributor::ProcessingData::CurToken() const |
| { |
| csv_assert( itCurToken != aTokenQueue.end() ); |
| csv_assert( *itCurToken != 0 ); |
| return *(*itCurToken); |
| } |
| |
| inline UnoIDL_PE & |
| TokenDistributor::ProcessingData::CurEnv() const |
| { |
| csv_assert( aEnvironments.size() > 0 ); |
| csv_assert( aEnvironments.back().first != 0 ); |
| return *aEnvironments.back().first; |
| } |
| |
| inline UnoIDL_PE & |
| TokenDistributor::ProcessingData::PushEnv() const |
| { |
| csv_assert( aCurResult.pEnv2Push != 0 ); |
| return *aCurResult.pEnv2Push; |
| } |
| |
| inline uintt |
| TokenDistributor::ProcessingData::CurTokenPosition() const |
| { |
| return itCurToken - aTokenQueue.begin(); |
| } |
| |
| inline uintt |
| TokenDistributor::ProcessingData::CurEnv_TriedTokenPosition() const |
| { |
| csv_assert( aEnvironments.size() > 0 ); |
| return aEnvironments.back().second; |
| } |
| |
| |
| } // namespace uidl |
| } // namespace csi |
| |
| #endif |
| |