HistoryLogData.h

Go to the documentation of this file.

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

#ifndef ZYPP_HISTORYLOGDATA_H_
#define ZYPP_HISTORYLOGDATA_H_

#include <iosfwd>

#include "zypp/APIConfig.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;

    static const HistoryActionID INSTALL;
    static const HistoryActionID REMOVE;
    static const HistoryActionID REPO_ADD;
    static const HistoryActionID REPO_REMOVE;
    static const HistoryActionID REPO_CHANGE_ALIAS;
    static const HistoryActionID REPO_CHANGE_URL;
    static const HistoryActionID STAMP_COMMAND;
    static const HistoryActionID PATCH_STATE_CHANGE;

    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 HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogData>          Ptr;
    typedef shared_ptr<const HistoryLogData>    constPtr;

    typedef std::vector<std::string>    FieldVector;
    typedef FieldVector::size_type      size_type;
    typedef FieldVector::const_iterator 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 HistoryLogDataInstall : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataInstall>           Ptr;
    typedef shared_ptr<const HistoryLogDataInstall>     constPtr;
    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 HistoryLogPatchStateChange : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogPatchStateChange>              Ptr;
    typedef shared_ptr<const HistoryLogPatchStateChange>        constPtr;
    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 HistoryLogDataRemove : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataRemove>            Ptr;
    typedef shared_ptr<const HistoryLogDataRemove>      constPtr;
    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 HistoryLogDataRepoAdd : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataRepoAdd>           Ptr;
    typedef shared_ptr<const HistoryLogDataRepoAdd>     constPtr;
    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 HistoryLogDataRepoRemove : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataRepoRemove>        Ptr;
    typedef shared_ptr<const HistoryLogDataRepoRemove>  constPtr;
    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 HistoryLogDataRepoAliasChange : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataRepoAliasChange>           Ptr;
    typedef shared_ptr<const HistoryLogDataRepoAliasChange>     constPtr;
    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 HistoryLogDataRepoUrlChange : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataRepoUrlChange>             Ptr;
    typedef shared_ptr<const HistoryLogDataRepoUrlChange>       constPtr;
    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 HistoryLogDataStampCommand : public HistoryLogData
  {
  public:
    typedef shared_ptr<HistoryLogDataStampCommand>              Ptr;
    typedef shared_ptr<const HistoryLogDataStampCommand>        constPtr;
    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_ */