libgloox-dev 1.0.11-1 / usr / include / gloox / forward.h

This file is indexed.

/usr/include/gloox/forward.h is in libgloox-dev 1.0.11-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
/*
  Copyright (c) 2013-2014 by Jakob Schroeter <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 FORWARD_H__
#define FORWARD_H__

#include "stanzaextension.h"

#include <string>

namespace gloox
{

  class DelayedDelivery;
  class Stanza;

  /**
   * @brief This is an implementation of Stanza Forwarding (@xep{0297}) as a StanzaExtension.
   *
   * @note At this point, Forward can only hold forwarded Messages, not IQ or Presence.
   * However, Forward can be used inside any type of stanza (&lt;message&gt;, &lt;iq&gt;,
   * or &lt;presence&gt;).
   * 
   * XEP-Version: 0.5
   *
   * @author Jakob Schroeter <js@camaya.net>
   * @author Fernando Sanchez
   * @since 1.0.5
   */
  class GLOOX_API Forward : public StanzaExtension
  {
    public:

      /**
       * Creates a forwarding StanzaExtension, embedding the given Stanza and DelayedDelivery objects.
       * @param stanza The forwarded Stanza. This Forward instance will own the Stanza object.
       * @param delay The date/time the forwarded stanza was received at by the forwarder. This
       * Forward instance will own the DelayedDelivery object.
       */
      Forward( Stanza* stanza, DelayedDelivery* delay );
      
      /**
       * Creates a forwarding Stanza from the given Tag. The original Tag will be ripped off.
       * If a valid Stanza is conatined (as a child) in the Tag it will be parsed, too.
       * It can then be accessed through embeddedStanza(). The Tag that the Stanza was built from
       * is available through embeddedTag().
       * @param tag The Tag to parse.
       */
      Forward( const Tag* tag = 0 );

      /**
       * Virtual destructor.
       */
      virtual ~Forward();

      /**
       * This function returns a pointer to a DelayedDelivery StanzaExtension which indicates
       * when the forwarder originally received the forwarded stanza.
       * 
       * @return A pointer to a DelayedDelivery object. May be 0.
       */
      const DelayedDelivery* when() const { return m_delay; }

      // reimplemented from Stanza
      virtual Stanza* embeddedStanza() const { return m_stanza; }
      
      // reimplemented from Stanza
      virtual Tag* embeddedTag() const { return m_tag; }
      
      // reimplemented from Stanza
      virtual Tag* tag() const;

      // reimplemented from Stanza
      const std::string& filterString() const;
      
      // reimplemented from Stanza
      StanzaExtension* newInstance( const Tag* tag ) const
      {
        return new Forward( tag );
      }

      // reimplemented from Stanza
      StanzaExtension* clone() const;

    private:
      Stanza* m_stanza;
      Tag* m_tag;
      DelayedDelivery* m_delay;

  };

}

#endif // FORWARD_H__

APT Browse - Built by Thomas Orozco.