iodata.h

/*
  Copyright (c) 2015-2023 by Jakob Schröter <js@camaya.net>
  This file is part of the gloox library. http://camaya.net/gloox
 
  This software is distributed under a license. The full license
  agreement can be found in the file LICENSE in this distribution.
  This software may not be copied, modified, sold or distributed
  other than expressed in the named license agreement.
 
  This software is distributed without any warranty.
*/
 
 
#ifndef IODATA_H__
#define IODATA_H__
 
#include "adhocplugin.h"
 
#include "gloox.h"
#include "tag.h"
 
#include <string>
 
namespace gloox
{
 
  class GLOOX_API IOData : public AdhocPlugin
  {
    public:
      enum Type
      {
        TypeIoSchemataGet,           
        TypeInput,                   
        TypeGetStatus,               
        TypeGetOutput,               
        TypeIoSchemataResult,        
        TypeOutput,                  
        TypeError,                   
        TypeStatus,                  
        TypeInvalid                  
      };
 
      struct Status
      {
        int elapsed;                 
        int remaining;               
        int percentage;              
        std::string info;            
      };
 
      IOData( Type type );
 
      IOData( const Tag* tag );
 
      virtual ~IOData();
 
      Type type() const { return m_type; }
 
      const Tag* in() const { return m_in; }
 
      void setIn( Tag* in );
 
      const Tag* out() const { return m_out; }
 
      void setOut( Tag* out );
 
      const Tag* error() const { return m_error; }
 
      void setError( Tag* error );
 
      void setDesc( const std::string& desc ) { m_desc = desc; }
 
      const std::string& desc() const { return m_desc; }
 
      void setStatus( Status status ) { m_status = status; }
 
      Status status() const { return m_status; }
 
      // reimplemented from AdhocPlugin/StanzaExtension
      virtual Tag* tag() const;
 
      // reimplemented from AdhocPlugin/StanzaExtension
      virtual IOData* clone() const;
 
      // reimplemented from AdhocPlugin/StanzaExtension
      virtual const std::string& filterString() const { return EmptyString; }
 
      // reimplemented from AdhocPlugin/StanzaExtension
      virtual StanzaExtension* newInstance( const Tag* /*tag*/ ) const { return 0; }
 
      operator bool() const { return m_type != TypeInvalid; }
 
  private:
    Tag* m_in;
    Tag* m_out;
    Tag* m_error;
 
    std::string m_desc;
 
    Status m_status;
 
    Type m_type;
 
  };
 
}
 
#endif // IODATA_H__