PackagesLangParser.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <iostream>
#include "zypp/base/Logger.h"

#include "zypp/source/susetags/PackagesLangParser.h"
#include "zypp/parser/tagfile/TagFileParser.h"
#include "zypp/Package.h"
#include "zypp/source/susetags/SuseTagsImpl.h"
#include "zypp/source/susetags/SuseTagsPackageImpl.h"

#include "zypp/ZYppFactory.h"

using std::endl;

namespace zypp
{ 

  namespace source
  { 

    namespace susetags
    { 

      using namespace parser::tagfile;

      struct PackagesLangParser : public parser::tagfile::TagFileParser
      {
        const PkgContent & _content;
        const Locale & _lang;
        PkgImplPtr _current;
        
        NVRA _nvra;
        int _count;
        std::set<NVRA> _notfound;
        Arch _system_arch;

        SuseTagsImpl::Ptr _sourceImpl;
        
        PackagesLangParser ( SuseTagsImpl::Ptr sourceimpl , const PkgContent & content_r, const Locale & lang_r)
            : _content( content_r )
            , _lang( lang_r)
            , _count(0)
            , _sourceImpl( sourceimpl )
               
        {
            ZYpp::Ptr z = getZYpp();
            _system_arch = z->architecture();
        }

        /* Consume SingleTag data. */
        virtual void consume( const SingleTag & stag_r )
        {
          if ( stag_r.name == "Pkg" )
          {
            std::vector<std::string> words;
            str::split( stag_r.value, std::back_inserter(words) );

            if ( str::split( stag_r.value, std::back_inserter(words) ) != 4 )
              ZYPP_THROW( ParseException( "[" + _file_r.asString() + "] Parse error in tag Pkg, expected [name version release arch], found: [" + stag_r.value + "]" ) );

            Arch arch( words[3] );
            _nvra = NVRA( words[0], Edition(words[1],words[2]), arch );
            // only discard the package if it is not compatible AND it does not provide data
            // to other packages
            if (!arch.compatibleWith( _system_arch ) && !_sourceImpl->_is_shared[_nvra])
            {
                _current = NULL;
                return;
            }
            
            PkgContent::const_iterator it = _content.find(NVRAD(_nvra));
            if (it == _content.end())
            {
              // package not found in the master package list
                _current = NULL;
                _notfound.insert(_nvra);
            }
            else
            {
              //WAR << "Data for package " << words[0] << " " << words[1] << " " << words[2] << "  " << Arch(words[3]) << " coming..." << endl;
                _count++;
                _current = it->second;
            }

          }
          else if ( stag_r.name == "Sum" )
          {
            if (_current != NULL)
              _sourceImpl->_package_data[_nvra]._summary = TranslatedText( stag_r.value, _lang);
          }
        }

        /* Consume MulitTag data. */
        virtual void consume( const MultiTag & mtag_r )
        {
          if ( _current == NULL )
            return;

          if ( mtag_r.name == "Des" )
            {
              _sourceImpl->_package_data[_nvra]._description = TranslatedText (mtag_r.values, _lang);
            }
          else if ( mtag_r.name == "Ins" )
            {
              _sourceImpl->_package_data[_nvra]._insnotify = TranslatedText (mtag_r.values, _lang);
            }
          else if ( mtag_r.name == "Del" )
            {
              _sourceImpl->_package_data[_nvra]._delnotify = TranslatedText (mtag_r.values, _lang);
            }
          else if ( mtag_r.name == "Eul" )
          {
            for ( std::list<std::string>::const_iterator it = mtag_r.values.begin(); it != mtag_r.values.end(); ++it)
              {
                _sourceImpl->_package_data[_nvra]._license_to_confirm += *it;
              }
          }
        }
      };


      void parsePackagesLang( SuseTagsImpl::Ptr sourceimpl, const Pathname & file_r, const Locale & lang_r, const PkgContent & content_r )
      {
        PackagesLangParser p ( sourceimpl, content_r, lang_r);
        MIL << "Starting with " << content_r.size() << " packages" << endl;
        try
        {
          p.parse( file_r );
        }
        catch(zypp::parser::tagfile::ParseException &e)
        {
          ZYPP_CAUGHT(e);
          ERR << "Packages Lang " << file_r << " is broken." << std::endl;
          return;
        }

        MIL << "Ending after " << p._count << " langs with " << content_r.size() << " packages and " << p._notfound.size() << " not founds." <<endl;
        WAR << "Not found packages:" << std::endl;
        for ( std::set<NVRA>::const_iterator it = p._notfound.begin(); it != p._notfound.end(); ++it)
        {
          NVRA nvra = *it;
          WAR << "-> " << nvra.name << " " << nvra.edition << " " << nvra.arch << std::endl;
        }
        return;
      }

    } // namespace susetags
  } // namespace source
} // namespace zypp

---