ResolvableQuery.h

Go to the documentation of this file.

#ifndef ZYPP_CACHE_RESOLVABLE_QUERY_H
#define ZYPP_CACHE_RESOLVABLE_QUERY_H

#include <set>
#include <list>
#include <vector>
#include "zypp/base/Function.h"
#include "zypp/Pathname.h"
#include "zypp/data/ResolvableData.h"
#include "zypp/data/RecordId.h"
#include "zypp/cache/Attribute.h"
#include "zypp/ZConfig.h"

#define queryOnMediaLocation(RESQUERY,ID,OMLATTRPREFIX,OML)                                              \
do {                                                                                                     \
  OML.setLocation( RESQUERY.queryStringAttribute( ID, OMLATTRPREFIX##Filename() ),                       \
                   RESQUERY.queryNumericAttribute( ID, OMLATTRPREFIX##MediaNr() ) );                     \
  OML.setChecksum( CheckSum( RESQUERY.queryStringAttribute( ID, OMLATTRPREFIX##ChecksumType() ),         \
                             RESQUERY.queryStringAttribute( ID, OMLATTRPREFIX##Checksum() ) ) );         \
  OML.setDownloadSize( RESQUERY.queryNumericAttribute( ID, OMLATTRPREFIX##DownloadSize() ) );            \
  OML.setOpenChecksum( CheckSum( RESQUERY.queryStringAttribute( ID, OMLATTRPREFIX##OpenChecksumType() ), \
                                 RESQUERY.queryStringAttribute( ID, OMLATTRPREFIX##OpenChecksum() ) ) ); \
  OML.setOpenSize( RESQUERY.queryNumericAttribute( ID, OMLATTRPREFIX##OpenSize() ) );                    \
} while(false)


namespace zypp
{ 

  namespace cache
  { 

   // match flag definitions for iterate*() functions

   const int MATCH_EXACT =      0x00;           // match 'string' exactly
   const int MATCH_LEADING =    0x01;           // match 'string*'
   const int MATCH_TRAILING =   0x02;           // match '*string'
   const int MATCH_SUBSTRING =  (MATCH_LEADING|MATCH_TRAILING);
   const int MATCH_REGEXP =     0x04;           // match e.g. 's?t*r??ing*' (only ? and * are allowed)
   const int MATCH_NAME =       0x08;           // match string in resolvable name, this is the default
   const int MATCH_SUMMARY =    0x10;           // match string in resolvable summary
   const int MATCH_DESCRIPTION= 0x20;           // match string in resolvable description


   const int MATCH_WILDCARDS = (MATCH_SUBSTRING|MATCH_REGEXP);
   const int MATCH_FIELDS = (MATCH_NAME|MATCH_SUMMARY|MATCH_DESCRIPTION);

      typedef function<bool( const data::RecordId &,
                             data::ResObject_Ptr )> ProcessResolvable;

    struct ResolvableQuery
    {
    public:
      ResolvableQuery( const Pathname &dbdir );

      ~ResolvableQuery();

      void query( const data::RecordId &record_id,
                  ProcessResolvable fnc  );

      void query( const std::string &text,
                  ProcessResolvable fnc  );

      int queryNumericAttribute( const data::RecordId &record_id,
                                 const std::string &klass,
                                 const std::string &name,
                                 int default_value = 0 );
      int queryNumericAttribute( const data::RecordId &record_id,
                                 const Attribute& attr,
                                 int default_value = 0 )
      { return queryNumericAttribute( record_id, attr.klass, attr.name, default_value ); }


      bool queryBooleanAttribute( const data::RecordId &record_id,
                                  const std::string &klass,
                                  const std::string &name,
                                  bool default_value = false );
      bool queryBooleanAttribute( const data::RecordId &record_id,
                                  const Attribute& attr,
                                  bool default_value = false )
      { return queryBooleanAttribute( record_id, attr.klass, attr.name, default_value ); }


      std::string queryStringAttribute( const data::RecordId &record_id,
                                        const std::string &klass,
                                        const std::string &name,
                                        const std::string &default_value = std::string() );
      std::string queryStringAttribute( const data::RecordId &record_id,
                                        const Attribute& attr,
                                        const std::string &default_value = std::string() )
      { return queryStringAttribute( record_id, attr.klass, attr.name, default_value ); }

      std::string queryStringAttributeTranslation( const data::RecordId &record_id,
                                                   const Locale &locale,
                                                   const std::string &klass,
                                                   const std::string &name,
                                                   const std::string &default_value = std::string() );
      std::string queryStringAttributeTranslation( const data::RecordId &record_id,
                                                   const Locale &locale,
                                                   const Attribute& attr,
                                                   const std::string &default_value = std::string() )
      { return queryStringAttributeTranslation( record_id, locale, attr.klass, attr.name, default_value ); }

      TranslatedText queryTranslatedStringAttribute( const data::RecordId &record_id,
                                                     const std::string &klass,
                                                     const std::string &name,
                                                     const TranslatedText &default_value = TranslatedText() );
      TranslatedText queryTranslatedStringAttribute( const data::RecordId &record_id,
                                                     const Attribute& attr,
                                                     const TranslatedText &default_value = TranslatedText() )
      { return queryTranslatedStringAttribute( record_id, attr.klass, attr.name, default_value ); }

      template<class _OutputIterator>
      void queryStringContainerAttribute( const data::RecordId &record_id,
                                    const std::string &klass,
                                    const std::string &name,
                                    _OutputIterator result )
      {

        std::string all = queryStringAttribute( record_id, klass, name);
        //FIXME use zypp separator
        str::split( all, result, ZConfig::instance().cacheDBSplitJoinSeparator() );
      }
      template<class _OutputIterator>
      void queryStringContainerAttribute( const data::RecordId &record_id,
                                          const Attribute& attr,
                                          _OutputIterator result )
      { queryStringContainerAttribute( record_id, attr.klass, attr.name, result ); }



      void queryDiskUsage( const data::RecordId &record_id,
                           DiskUsage &du );

      std::string queryRepositoryAlias( const data::RecordId &repo_id );

      data::RecordId queryRepositoryId( const std::string &repo_alias );

      void iterateResolvablesByKindsAndStringsAndRepos( const std::vector<zypp::Resolvable::Kind> & kinds,
                  const std::vector<std::string> &names, int flags, const std::vector<std::string> &repos, ProcessResolvable fnc );

    private:
      class Impl;
      RW_pointer<Impl> _pimpl;
    };
  } //NS cache
} //NS zypp

#endif

---