ResolvableData.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_DATA_RESOLVABLEDATA_H
#define ZYPP_DATA_RESOLVABLEDATA_H

#include <iosfwd>
#include <list>

#include "zypp/base/PtrTypes.h"
#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"

#include "zypp/data/RecordId.h"
#include "zypp/capability/CapabilityImpl.h"
#include "zypp/Pathname.h"
#include "zypp/Resolvable.h"
#include "zypp/NVR.h"
#include "zypp/Edition.h"
#include "zypp/ByteCount.h"
#include "zypp/Arch.h"
#include "zypp/CheckSum.h"
#include "zypp/Changelog.h"
#include "zypp/Url.h"
#include "zypp/Date.h"
#include "zypp/TranslatedText.h"
#include "zypp/OnMediaLocation.h"
#include "zypp/DiskUsage.h"

namespace zypp
{
namespace data
{
  typedef std::set<capability::CapabilityImpl::Ptr> DependencyList;
  typedef std::map<zypp::Dep, DependencyList>       Dependencies;

  typedef DefaultIntegral<unsigned,0u>              MediaNr;

  typedef std::list<std::string>                    Filenames;


  DEFINE_PTR_TYPE(Resolvable);

  class Resolvable : public base::ReferenceCounted, private base::NonCopyable
  {
    public:
      Resolvable()
      {};

      zypp::Resolvable::Kind kind;
      std::string name;
      Edition edition;
      Arch arch;
      Dependencies deps;
  };


  DEFINE_PTR_TYPE(ResObject);

  class ResObject : public Resolvable
  {
    public:
      ResObject()
      {}

      std::string sharedDataTag;
      RecordId shareDataWith;

      // Common attributes:
      std::string vendor;
      ByteCount installedSize;
      Date buildTime;

      // Flags:
      DefaultIntegral<bool,false> installOnly;

      // Translated texts:
      TranslatedText summary;
      TranslatedText description;
      TranslatedText licenseToConfirm;
      TranslatedText insnotify;
      TranslatedText delnotify;

      // Repository related:
      RecordId  repository;
    protected:
      virtual std::ostream & dumpOn( std::ostream & str ) const;
  };


  DEFINE_PTR_TYPE(Atom);

  /* Data Object for Atom resolvable. */
  class Atom : public ResObject
  {
    public:
      Atom()
      {};
  };


  DEFINE_PTR_TYPE(Script);

  /* Data Object for Script resolvable. */
  class Script : public ResObject
  {
    public:
      Script()
      {};

      std::string doScript;
      OnMediaLocation doScriptLocation;

      std::string undoScript;
      OnMediaLocation undoScriptLocation;
  };


  DEFINE_PTR_TYPE(Message);

  /* Data Object for Message resolvable. */
  class Message : public ResObject
  {
    public:
      Message()
      {};

      TranslatedText text;
  };


  DEFINE_PTR_TYPE(Patch);

  /* Data Object for Patch resolvable. */
  class Patch : public ResObject
  {
    public:
      Patch()
      {};

      std::string id;
      Date timestamp;
      std::string category;

      // Flags:
      DefaultIntegral<bool,false> rebootNeeded;
      DefaultIntegral<bool,false> affectsPkgManager;

      std::string updateScript;

      std::set<ResObject_Ptr> atoms;
  };


  DEFINE_PTR_TYPE(Pattern);

  /* Data Object for Pattern resolvable. */
  class Pattern : public ResObject
  {
    public:
      Pattern()
      {}

      // Flags
      DefaultIntegral<bool,false> isDefault;
      DefaultIntegral<bool,false> userVisible;

      TranslatedText category;

      std::string icon;
      std::string order;
      std::string script;

      DependencyList includes;
      DependencyList extends;
  };


  DEFINE_PTR_TYPE(Product);

  /* Data Object for Product resolvable. */
  class Product : public ResObject
  {
    public:
      Product()
      {};

      std::string type;

      TranslatedText shortName;
      TranslatedText longName;

      std::list<std::string> flags;

      Url releasenotesUrl;
      std::list<Url> updateUrls;
      std::list<Url> extraUrls;
      std::list<Url> optionalUrls;

      std::string distributionName;
      Edition distributionEdition;
  };


  DEFINE_PTR_TYPE(Packagebase);

  class Packagebase : public ResObject
  {
    public:
      enum PackageType { BIN, SRC, ATOM };
      virtual PackageType packageType() const = 0;

    public:
      std::string group;
      std::set<std::string> keywords;

      Changelog changelog;
      std::list<std::string> authors;


      std::string buildhost;
      std::string distribution;
      std::string license;
      std::string packager;
      std::string url;

      std::string operatingSystem;

      std::string prein;
      std::string postin;
      std::string preun;
      std::string postun;

      OnMediaLocation repositoryLocation;
      DiskUsage       diskusage;
  };

  DEFINE_PTR_TYPE(Package);
  struct Package : public Packagebase
  {
    virtual PackageType packageType() const { return BIN; }

    NVR srcPackageIdent;
  };

  DEFINE_PTR_TYPE(SrcPackage);
  struct SrcPackage : public Packagebase
  {
    virtual PackageType packageType() const { return SRC; }
  };

  // --- ---------------------------------------------------------------------
  // --- the following are the data structures for storing YUM package atom
  // --- metadata (part of patch support). This is probably subject to change
  // --- in near future.
  // --- ---------------------------------------------------------------------

  DEFINE_PTR_TYPE(BaseVersion);
  struct BaseVersion : public base::ReferenceCounted, private base::NonCopyable
  {
    Edition     edition;
  };

  struct RpmBase : public base::ReferenceCounted, private base::NonCopyable
  {
    // Base <patchrpm>/<deltarpm> element attributes

    std::string     name;     // target rpm name
    Edition         edition;  // target rpm edition
    Arch            arch;     // target rpm architecture
    OnMediaLocation location;
    Date            buildTime;
    Date            fileTime;
    ByteCount       archiveSize; // ??
    protected:
      virtual std::ostream & dumpOn( std::ostream & str ) const;
  };

  DEFINE_PTR_TYPE(PatchRpm);
  struct PatchRpm : RpmBase
  {
    std::set<BaseVersion_Ptr> baseVersions;
  };

  DEFINE_PTR_TYPE(DeltaRpm);
  struct DeltaRpm : RpmBase
  {
    struct DeltaBaseVersion : BaseVersion
    {
      Date        buildTime;
      CheckSum    checkSum;
      std::string sequenceInfo;
    };

    DeltaBaseVersion baseVersion;
  };

  DEFINE_PTR_TYPE(PackageAtom);
  struct PackageAtom : public Package
  {
    std::set<PatchRpm_Ptr> patchRpms;
    std::set<DeltaRpm_Ptr> deltaRpms;
    // TODO support mulitple licenses (licenseToConfirm)
  };

  // --- ----------END--YUM-package-atom-metadata-----------------------------


} // namespace data
} // namespace zypp
#endif // ZYPP_DATA_RESOLVABLEDATA_H

---