HistoryLogData.h

Go to the documentation of this file.

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

#ifndef ZYPP_HISTORYLOGDATA_H_
#define ZYPP_HISTORYLOGDATA_H_
 
#include <iosfwd>
 
#include <zypp-core/Globals.h>
#include <zypp/Date.h>
#include <zypp/Edition.h>
#include <zypp/Arch.h>
#include <zypp/CheckSum.h>
#include <zypp/Url.h>
#include <zypp/Patch.h>
 
#define HISTORY_LOG_DATE_FORMAT "%Y-%m-%d %H:%M:%S"

namespace zypp
{
  struct HistoryActionID
  {
    static const HistoryActionID NONE ZYPP_API;
 
    static const HistoryActionID INSTALL ZYPP_API;
    static const HistoryActionID REMOVE ZYPP_API;
    static const HistoryActionID REPO_ADD ZYPP_API;
    static const HistoryActionID REPO_REMOVE ZYPP_API;
    static const HistoryActionID REPO_CHANGE_ALIAS ZYPP_API;
    static const HistoryActionID REPO_CHANGE_URL ZYPP_API;
    static const HistoryActionID STAMP_COMMAND ZYPP_API;
    static const HistoryActionID PATCH_STATE_CHANGE ZYPP_API;
 
    enum ID
    {
      NONE_e,
 
      INSTALL_e,
      REMOVE_e,
      REPO_ADD_e,
      REPO_REMOVE_e,
      REPO_CHANGE_ALIAS_e,
      REPO_CHANGE_URL_e,
      STAMP_COMMAND_e,
      PATCH_STATE_CHANGE_e
    };
 
    HistoryActionID() : _id(NONE_e) {}
 
    HistoryActionID(ID id) : _id(id) {}
 
    explicit HistoryActionID(const std::string & strval_r);
 
    ID toEnum() const { return _id; }
 
    static HistoryActionID::ID parse(const std::string & strval_r);
 
    const std::string & asString(bool pad = false) const;
 
    private:
    ID _id;
  };

  inline bool operator==( const HistoryActionID & lhs, const HistoryActionID & rhs )
  { return lhs.toEnum() == rhs.toEnum(); }

  inline bool operator!=( const HistoryActionID & lhs, const HistoryActionID & rhs )
  { return lhs.toEnum() != rhs.toEnum(); }

  std::ostream & operator << (std::ostream & str, const HistoryActionID & id);

  class ZYPP_API HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogData>;
    using constPtr = shared_ptr<const HistoryLogData>;
 
    using FieldVector = std::vector<std::string>;
    using size_type = FieldVector::size_type;
    using const_iterator = FieldVector::const_iterator;
 
  public:
    explicit HistoryLogData( FieldVector & fields_r, size_type expect_r = 2 );

    HistoryLogData( FieldVector & fields_r, HistoryActionID action_r, size_type expect_r = 2 );

    virtual ~HistoryLogData();

    static Ptr create( FieldVector & fields_r );
 
  public:
    bool empty() const;

    size_type size() const;

    const_iterator begin() const;

    const_iterator end() const;

    const std::string & optionalAt( size_type idx_r ) const;
    const std::string & operator[]( size_type idx_r ) const
    { return optionalAt( idx_r ); }

    const std::string & at( size_type idx_r ) const;
 
  public:
    enum Index                     
    {
      DATE_INDEX      = 0,    
      ACTION_INDEX  = 1,    
    };
 
  public:
    Date    date()          const;  
    HistoryActionID action()     const;  
 
  public:
    class Impl;                 
  private:
    RWCOW_pointer<Impl> _pimpl; 
  protected:
    HistoryLogData & operator=( const HistoryLogData & ); 
  };

  std::ostream & operator<<( std::ostream & str, const HistoryLogData & obj );

  class ZYPP_API HistoryLogDataInstall : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataInstall>;
    using constPtr = shared_ptr<const HistoryLogDataInstall>;
    HistoryLogDataInstall( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      NAME_INDEX,             
      EDITION_INDEX,               
      ARCH_INDEX,             
      REQBY_INDEX,           
      REPOALIAS_INDEX,           
      CHEKSUM_INDEX,               
      USERDATA_INDEX,             
    };
 
   public:
    std::string name()          const;  
    Edition      edition()       const;  
    Arch    arch()          const;  
    std::string reqby()         const;  
    std::string repoAlias()     const;  
    CheckSum    checksum()      const;  
    std::string userdata()      const;  
  };
 
  //PATCH SEVERITY CATEGORY OLDSTATE NEWSTATE
  class ZYPP_API HistoryLogPatchStateChange : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogPatchStateChange>;
    using constPtr = shared_ptr<const HistoryLogPatchStateChange>;
    HistoryLogPatchStateChange( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      NAME_INDEX,             
      EDITION_INDEX,               
      ARCH_INDEX,             
      REPOALIAS_INDEX,           
      SEVERITY_INDEX,           
      CATEGORY_INDEX,           
      OLDSTATE_INDEX,           
      NEWSTATE_INDEX,           
      USERDATA_INDEX,             
    };
 
  public:
    std::string name()          const;  
    Edition      edition()       const;  
    Arch    arch()          const;  
    std::string repoAlias()     const;  
    Patch::SeverityFlag severity() const;
    Patch::Category category()  const;
    std::string oldstate()      const;
    std::string newstate()      const;
    std::string userdata()      const;  
  };
 

  class ZYPP_API HistoryLogDataRemove : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataRemove>;
    using constPtr = shared_ptr<const HistoryLogDataRemove>;
    HistoryLogDataRemove( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      NAME_INDEX,             
      EDITION_INDEX,               
      ARCH_INDEX,             
      REQBY_INDEX,           
      USERDATA_INDEX,             
    };
 
  public:
    std::string name()          const;  
    Edition      edition()       const;  
    Arch    arch()          const;  
    std::string reqby()         const;  
    std::string userdata()      const;  
  };

  class ZYPP_API HistoryLogDataRepoAdd : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataRepoAdd>;
    using constPtr = shared_ptr<const HistoryLogDataRepoAdd>;
    HistoryLogDataRepoAdd( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      ALIAS_INDEX,           
      URL_INDEX,               
      USERDATA_INDEX,             
    };
 
  public:
    std::string alias()         const;  
    Url              url()                const;  
    std::string userdata()      const;  
  };

  class ZYPP_API HistoryLogDataRepoRemove : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataRepoRemove>;
    using constPtr = shared_ptr<const HistoryLogDataRepoRemove>;
    HistoryLogDataRepoRemove( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      ALIAS_INDEX,           
      USERDATA_INDEX,             
    };
 
  public:
    std::string alias()         const;  
    std::string userdata()      const;  
  };

  class ZYPP_API HistoryLogDataRepoAliasChange : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataRepoAliasChange>;
    using constPtr = shared_ptr<const HistoryLogDataRepoAliasChange>;
    HistoryLogDataRepoAliasChange( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      OLDALIAS_INDEX,             
      NEWALIAS_INDEX,             
      USERDATA_INDEX,             
   };
 
  public:
    std::string oldAlias()      const;  
    std::string newAlias()      const;  
    std::string userdata()      const;  
  };

  class ZYPP_API HistoryLogDataRepoUrlChange : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataRepoUrlChange>;
    using constPtr = shared_ptr<const HistoryLogDataRepoUrlChange>;
    HistoryLogDataRepoUrlChange( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      ALIAS_INDEX,           
      NEWURL_INDEX,         
      USERDATA_INDEX,             
   };
 
  public:
    std::string alias()         const;  
    Url              newUrl()        const;  
    std::string userdata()      const;  
  };

  class ZYPP_API HistoryLogDataStampCommand : public HistoryLogData
  {
  public:
    using Ptr = shared_ptr<HistoryLogDataStampCommand>;
    using constPtr = shared_ptr<const HistoryLogDataStampCommand>;
    HistoryLogDataStampCommand( FieldVector & fields_r );
 
  public:
    enum Index                     
    {
      DATE_INDEX      = HistoryLogData::DATE_INDEX,
      ACTION_INDEX  = HistoryLogData::ACTION_INDEX,
      USER_INDEX,             
      COMMAND_INDEX,               
      USERDATA_INDEX,             
   };
 
  public:
    std::string executedBy()            const;  
    std::string command()               const;  
    std::string userdata()              const;  
  };
 
} // namespace zypp
#endif /* ZYPP_HISTORYLOGDATA_H_ */