libbase/StreamProvider.h

   1 //
   2 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   3 //   Foundation, Inc
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19 #ifndef GNASH_STREAMPROVIDER_H
  20 #define GNASH_STREAMPROVIDER_H
  21
  22 #include "NetworkAdapter.h"
  23 #include "dsodefs.h" // for DSOEXPORT
  24 #include "NamingPolicy.h"
  25
  26 #include <string>
  27 #include <memory>
  28
  29 // Forward declarations
  30 namespace gnash {
  31         class URL;
  32         class IOChannel;
  33 }
  34
  35
  36 namespace gnash {
  37
  38 /// A StreamProvider makes IOChannels available to the core on request.
  39 //
  40 /// The current functions of this class are:
  41 /// 1. Inform users whether a connection to a certain URL is allowed.
  42 /// 2. Make a connection and return an IOChannel (this performs a separate
  43 ///    access check).
  44 ///
  45 /// The class should in future also:
  46 /// 3. Take relative URLs and resolve them against the base URL.
  47 //
  48 /// TODO: this class should become an abstract interface.
  49 class DSOEXPORT StreamProvider
  50 {
  51 public:
  52
  53     /// Construct a StreamProvider
  54     //
  55     /// @param original     The original URL, used to decide whether to allow
  56     ///                     connections.
  57     /// @param base         The base URL, used to resolve URLs.
  58     /// @param np           A policy to decide the name of cached files.
  59         StreamProvider(const URL& original, const URL& base,
  60             std::auto_ptr<NamingPolicy> np =
  61             std::auto_ptr<NamingPolicy>(new NamingPolicy));
  62
  63         virtual ~StreamProvider() {}
  64
  65         /// Returned stream ownership is transferred to caller.
  66         //
  67         /// On error NULL is returned
  68         /// Derive from this for a CachingStreamProvider
  69         virtual std::auto_ptr<IOChannel> getStream(const URL& url,
  70             bool namedCacheFile = false) const;
  71
  72         /// Get a stream from the response of a POST operation
  73         //
  74         /// Returned stream ownership is transferred to caller.
  75         ///
  76         /// On error NULL is returned
  77         /// Derive from this for a CachingStreamProvider
  78         ///
  79         /// @param url      The url to post to.
  80         /// @param postdata Post data in url-encoded form.
  81         virtual std::auto_ptr<IOChannel> getStream(const URL& url,
  82             const std::string& postdata, bool namedCacheFile = false) const;
  83
  84         virtual std::auto_ptr<IOChannel> getStream(const URL& url,
  85             const std::string& postdata,
  86             const NetworkAdapter::RequestHeaders& headers,
  87             bool namedCacheFile = false) const;
  88
  89     /// Set the NamingPolicy for cache files
  90     //
  91     /// This is only used when cache file naming is requested in getStream()
  92     /// This StreamProvider owns the NamingPolicy instance.
  93     void setNamingPolicy(std::auto_ptr<NamingPolicy> np) {
  94         _namingPolicy = np;
  95     }
  96
  97     /// Return the currently selected policy for converting URL to filename
  98     const NamingPolicy& namingPolicy() const {
  99         assert(_namingPolicy.get());
 100         return *_namingPolicy;
 101     }
 102
 103     /// Check whether access to a URL is allowed
 104     //
 105     /// This is used by the core to check whether a connection can be
 106     /// made before trying to make it. It's useful currently for
 107     /// some functions to decide what to return.
 108     //
 109     /// @param url      The url to check
 110     /// @return         true if allowed, false if not.
 111     bool allow(const URL& url) const;
 112
 113     /// The base URL that should be used to resolve all relative URLs.
 114     //
 115     /// TODO: drop this if possible and handle all resolution in
 116     /// this class.
 117     const URL& baseURL() const {
 118         return _base;
 119     }
 120
 121 private:
 122
 123     /// The current naming policy for cache files.
 124     std::auto_ptr<NamingPolicy> _namingPolicy;
 125
 126     const URL _base;
 127
 128     const URL _original;
 129
 130 };
 131
 132 } // namespace gnash
 133
 134 #endif
 135
 136
 137 // Local Variables:
 138 // mode: C++
 139 // indent-tabs-mode: t
 140 // End: