HistoryLogData.h

Go to the documentation of this file.

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

#ifndef ZYPP_HISTORYLOGDATA_H_
#define ZYPP_HISTORYLOGDATA_H_

#include <iosfwd>

#include "base/Deprecated.h"
#include "zypp/Date.h"
#include "zypp/Edition.h"
#include "zypp/Arch.h"
#include "zypp/CheckSum.h"
#include "zypp/Url.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;

    enum ID
    {
      NONE_e,

      INSTALL_e,
      REMOVE_e,
      REPO_ADD_e,
      REPO_REMOVE_e,
      REPO_CHANGE_ALIAS_e,
      REPO_CHANGE_URL_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;  
  };

  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;  
  };


#if defined(WITH_DEPRECATED_HISTORYITEM_API)






  class HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItem> Ptr;
    typedef std::vector<std::string> FieldVector;

  public:
    HistoryItem(FieldVector & fields);
    virtual ~HistoryItem()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    Date date;
    HistoryActionID action;
  };


  //
  // CLASS NAME: HistoryItemInstall
  //
  class ZYPP_DEPRECATED HistoryItemInstall : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemInstall> Ptr;

    HistoryItemInstall(FieldVector & fields);
    virtual ~HistoryItemInstall()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    std::string   name;
    Edition       edition;
    Arch          arch;
    std::string   reqby; // TODO make this a class ReqBy
    std::string   repoalias;
    CheckSum      checksum;
  };


  //
  // CLASS NAME: HistoryItemRemove
  //
  class ZYPP_DEPRECATED HistoryItemRemove : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemRemove> Ptr;

    HistoryItemRemove(FieldVector & fields);
    virtual ~HistoryItemRemove()
    {}

    virtual void dumpTo(std::ostream & str)  const;

  public:
    std::string name;
    Edition     edition;
    Arch        arch;
    std::string reqby;
  };


  //
  // CLASS NAME: HistoryItemRepoAdd
  //
  class ZYPP_DEPRECATED HistoryItemRepoAdd : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemRepoAdd> Ptr;

    HistoryItemRepoAdd(FieldVector & fields);
    virtual ~HistoryItemRepoAdd()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    std::string alias;
    Url         url;
  };


  //
  // CLASS NAME: HistoryItemRepoRemove
  //
  class ZYPP_DEPRECATED HistoryItemRepoRemove : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemRepoRemove> Ptr;

    HistoryItemRepoRemove(FieldVector & fields);
    virtual ~HistoryItemRepoRemove()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    std::string alias;
  };


  //
  // CLASS NAME: HistoryItemRepoAliasChange
  //
  class ZYPP_DEPRECATED HistoryItemRepoAliasChange : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemRepoAliasChange> Ptr;

    HistoryItemRepoAliasChange(FieldVector & fields);
    virtual ~HistoryItemRepoAliasChange()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    std::string oldalias;
    std::string newalias;
  };


  //
  // CLASS NAME: HistoryItemRepoUrlChange
  //
  class ZYPP_DEPRECATED HistoryItemRepoUrlChange : public HistoryItem
  {
  public:
    typedef shared_ptr<HistoryItemRepoUrlChange> Ptr;

    HistoryItemRepoUrlChange(FieldVector & fields);
    virtual ~HistoryItemRepoUrlChange()
    {}

    virtual void dumpTo(std::ostream & str) const;

  public:
    std::string alias;
    Url newurl;
  };

  std::ostream & operator<<(std::ostream & str, const HistoryItem & obj);
#endif // WITH_DEPRECATED_HISTORYITEM_API

} // namespace zypp
#endif /* ZYPP_HISTORYLOGDATA_H_ */