CacheStore.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/

#ifndef ZYPP_CacheStore_H
#define ZYPP_CacheStore_H

#include <iosfwd>
#include <string>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/Pathname.h"
#include "zypp/NVRA.h"
#include "zypp/ZConfig.h"
#include "zypp/capability/CapabilityImpl.h"
#include "zypp/capability/Capabilities.h"

#include "zypp/data/ResolvableDataConsumer.h"
#include "zypp/data/RecordId.h"

#include "zypp/base/PtrTypes.h"
#include "zypp/RepoStatus.h"
#include "zypp/ProgressData.h"
#include "zypp/cache/Attribute.h"

namespace zypp
{ 

  namespace cache
  { 

    class CacheStore : public data::ResolvableDataConsumer
    {
    public:

      CacheStore();
      virtual ~CacheStore();

      CacheStore( const Pathname &dbdir );

      void commit();

      virtual data::RecordId consumePackage(const data::RecordId &repository_id,
                                            const data::Package_Ptr & package);

      virtual data::RecordId consumeSourcePackage( const data::RecordId &catalog_id,
                                                   const data::SrcPackage_Ptr & srcpackage );

      virtual data::RecordId consumePatch( const data::RecordId &repository_id,
                                           const data::Patch_Ptr & patch );

      virtual data::RecordId consumePackageAtom( const data::RecordId &repository_id,
                                                 const data::PackageAtom_Ptr & atom );

      virtual data::RecordId consumeMessage( const data::RecordId & repository_id,
                                             const data::Message_Ptr & message);

      virtual data::RecordId consumeScript( const data::RecordId & repository_id,
                                            const data::Script_Ptr & script);

      virtual data::RecordId consumePattern( const data::RecordId & repository_id,
                                             const data::Pattern_Ptr & pattern );

      virtual data::RecordId consumeProduct( const data::RecordId &repository_id,
                                             const data::Product_Ptr & product );

      virtual data::RecordId consumeChangelog( const data::RecordId & resolvable_id,
                                               const Changelog & changelog );

      virtual data::RecordId consumeFilelist( const data::RecordId & resolvable_id,
                                              const data::Filenames & filenames );
      
       virtual void consumeDiskUsage( const data::RecordId &resolvable_id,
                                      const DiskUsage &disk );


      virtual void updatePackageLang( const data::RecordId & resolvable_id,
                                      const data::Packagebase_Ptr & data_r );
      public:
      data::RecordId appendResolvable( const data::RecordId &repository_id,
                                       const Resolvable::Kind &kind,
                                       const NVRA &nvra,
                                       const data::Dependencies &deps );

      data::RecordId appendResolvable( const data::RecordId &repository_id,
                                       const Resolvable::Kind &kind,
                                       const NVRA &nvra,
                                       const data::Dependencies &deps,
                                       const data::RecordId &shared_id );
      void appendDependencies( const data::RecordId &resolvable_id,
                               const data::Dependencies &dependencies );

      void appendDependencyList( const data::RecordId &resolvable_id,
                                 zypp::Dep deptype,
                                 const data::DependencyList &dlist );

      void appendDependency( const data::RecordId &resolvable_id,
                             zypp::Dep deptype,
                             capability::CapabilityImpl::Ptr cap );

      void appendNamedDependency( const data::RecordId &, zypp::Dep,
                                  capability::NamedCap::Ptr);

      void appendFileDependency( const data::RecordId &, zypp::Dep,
                                 capability::FileCap::Ptr);

      void appendModaliasDependency( const data::RecordId &resolvable_id,
                                     zypp::Dep deptype,
                                     capability::ModaliasCap::Ptr cap);

      void appendHalDependency( const data::RecordId &resolvable_id,
                                      zypp::Dep deptype,
                                      capability::HalCap::Ptr cap );

      void appendFilesystemDependency( const data::RecordId &resolvable_id,
                                       zypp::Dep deptype,
                                       capability::FilesystemCap::Ptr cap );
      
      void appendSplitDependency( const data::RecordId &resolvable_id,
                                  zypp::Dep deptype,
                                  capability::SplitCap::Ptr cap );
      
      void appendUnknownDependency( const data::RecordId &resolvable_id,
                                    zypp::Dep deptype,
                                    capability::CapabilityImpl::Ptr cap );

      data::RecordId appendPatchRpm( const data::RecordId &repo_id,
                                     const data::PatchRpm_Ptr & prpm);


      data::RecordId appendDeltaRpm( const data::RecordId &repo_id,
                                     const data::DeltaRpm_Ptr & drpm);


      data::RecordId lookupOrAppendType( const std::string &klass,
                                         const std::string &name );
      data::RecordId lookupOrAppendType( const Attribute &attr )
      { return lookupOrAppendType( attr.klass, attr.name ); }

      data::RecordId lookupOrAppendRepository( const std::string &alias );

      void setSharedData( const data::RecordId &resolvable_id,
                          const data::RecordId &shared_id );

      void appendNumericAttribute( const data::RecordId &resolvable_id,
                                   const std::string &klass,
                                   const std::string &name,
                                   int value );
      void appendNumericAttribute( const data::RecordId &resolvable_id,
                                   const Attribute& attr,
                                   int value )
      { appendNumericAttribute( resolvable_id, attr.klass, attr.name, value ); }

      void appendTranslatedStringAttribute( const data::RecordId &resolvable_id,
                                            const std::string &klass,
                                            const std::string &name,
                                            const TranslatedText &text );
      void appendTranslatedStringAttribute( const data::RecordId &resolvable_id,
                                            const Attribute& attr,
                                            const TranslatedText &text )
      { appendTranslatedStringAttribute( resolvable_id, attr.klass, attr.name, text ); }

      void appendStringAttributeTranslation( const data::RecordId &resolvable_id,
                                             const Locale &locale,
                                             const std::string &klass,
                                             const std::string &name,
                                             const std::string &text );
      void appendStringAttributeTranslation( const data::RecordId &resolvable_id,
                                             const Locale &locale,
                                             const Attribute& attr,
                                             const std::string &text )
      { appendStringAttributeTranslation( resolvable_id, locale, attr.klass, attr.name, text ); }

      void appendStringAttribute( const data::RecordId &resolvable_id,
                                  const std::string &klass,
                                  const std::string &name,
                                  const std::string &value );
      void appendStringAttribute( const data::RecordId &resolvable_id,
                                  const Attribute& attr,
                                  const std::string &value )
      { appendStringAttribute( resolvable_id, attr.klass, attr.name, value ); }

      void appendStringAttribute( const data::RecordId &resolvable_id,
                                  const data::RecordId &type_id,
                                  const std::string &value );

      template <class _Iterator>
      void appendStringContainerAttribute( const data::RecordId &resolvable_id,
                                           const std::string &klass,
                                           const std::string &name,
                                           _Iterator begin,
                                           _Iterator end )
      {
        std::string value = str::join(begin, end, ZConfig::instance().cacheDBSplitJoinSeparator());
        appendStringAttribute( resolvable_id, klass, name, value );
      }
      template <class _Iterator>
      void appendStringContainerAttribute( const data::RecordId &resolvable_id,
                                           const Attribute& attr,
                                           _Iterator begin,
                                           _Iterator end )
      { appendStringContainerAttribute( resolvable_id, attr.klass, attr.name, begin, end ); }

      template <class _Container>
      void appendStringContainerAttribute( const data::RecordId &resolvable_id,
                                           const std::string &klass,
                                           const std::string &name,
                                           const _Container & container )
      { appendStringContainerAttribute( resolvable_id, klass, name, container.begin(), container.end() ); }
      template <class _Container>
      void appendStringContainerAttribute( const data::RecordId &resolvable_id,
                                           const Attribute& attr,
                                           const _Container & container )
      { appendStringContainerAttribute( resolvable_id, attr.klass, attr.name, container ); }

      void updateRepositoryStatus( const data::RecordId &id,
                                   const RepoStatus &status );

      void cleanRepository( const data::RecordId &id,
                            const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );

      void cleanRepository( const std::string &alias,
                            const ProgressData::ReceiverFnc & progressrcv = ProgressData::ReceiverFnc() );

      RepoStatus repositoryStatus( const data::RecordId &id );

      RepoStatus repositoryStatus( const std::string &alias );

      bool isCached( const std::string &alias );

      data::RecordId lookupRepository( const std::string &alias );


      data::RecordId lookupOrAppendFile( const Pathname &path );

      data::RecordId lookupOrAppendName( const std::string &name );

      data::RecordId lookupOrAppendDirName( const std::string &name );

      data::RecordId lookupOrAppendFileName( const std::string &name );

    protected:
//       data::RecordId appendDependencyEntry( const data::RecordId &,
//                                             zypp::Dep, const Resolvable::Kind & );

      void appendStringAttribute( const data::RecordId &resolvable_id,
                                  const data::RecordId &lang_id,
                                  const data::RecordId &type_id,
                                  const std::string &value );

      void appendNumericAttribute( const data::RecordId &resolvable_id,
                                   const data::RecordId &type_id,
                                   int value );

      void appendBooleanAttribute( const data::RecordId & resolvable_id,
                                   const std::string & klass,
                                   const std::string & name,
                                   bool value);
      void appendBooleanAttribute( const data::RecordId & resolvable_id,
                                   const Attribute& attr,
                                   bool value)
      { appendBooleanAttribute( resolvable_id, attr.klass, attr.name, value ); }


      void appendResObjectAttributes( const data::RecordId &rid,
                                      const data::ResObject_Ptr & res );

      void appendPackageBaseAttributes(const data::RecordId & pkgid,
                                       const data::Packagebase_Ptr & package);


    private:
      class Impl;
      RW_pointer<Impl> _pimpl;
    };
  }
}

#endif

---