URL.cc

/* -*- c++ -*-
 * $Id: URL.cc,v 1.12 2006/03/27 19:17:47 brook Exp $
 */

/*
 * ClearSilver++ Software License.
 *
 * Copyright (c) 2005,2006 Brook Milligan <brook@nmsu.edu>
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 * 3. The name of the author may not be used to endorse or promote
 *    products derived from this software without specific prior
 *    written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "URL.h"
#include "ClearSilverError.h"
#include "ClearSilverException.h"

#include <ClearSilver/cgi/cgi.h>

using namespace std;

#if !HAVE_UNSIGNED_URL
#include "c_string.h"
#endif

#if HAVE_UNSIGNED_URL
// exception-safe string conversions
template <class Destination,class Source>
class convert
{
  Destination * s_;

private:                        // enforce reference semantics
  convert (const convert&);
  convert& operator = (const convert&);

public:
  convert (const Source * s);
  ~convert ();
  operator Destination * () const;
  Destination * operator () () const;
};
#endif // HAVE_UNSIGNED_URL

namespace ClearSilver
{
                                // constructors
URL::URL () : url_() {}
URL::URL (const char * s) : url_()
{
#if HAVE_UNSIGNED_URL
  unsigned char * url;
  ClearSilverError error
    (cgi_url_escape (convert<unsigned char,char>(s), &url));
  if (error)
    {
      string message;
      message += "ClearSilver::URL::URL (const char*): ";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
  convert<char,unsigned char> c (url);
  url_ = c();
#else // HAVE_UNSIGNED_URL
  char * url;
  cgi_url_escape (c_string(s), &url);
  url_ = url;
#endif // HAVE_UNSIGNED_URL
}
URL::URL (const string& s) : url_()
{
#if HAVE_UNSIGNED_URL
  unsigned char * url;
  ClearSilverError error
    (cgi_url_escape (convert<unsigned char,char>(s.c_str()), &url));
  if (error)
    {
      string message;
      message += "ClearSilver::URL::URL (const string&): ";
      ClearSilverException e (message);
      e += error;
      throw e;
    }
  convert<char,unsigned char> c (url);
  url_ = c();
#else  // HAVE_UNSIGNED_URL
  char * url;
  cgi_url_escape (c_string(s), &url);
  url_ = url;
#endif // HAVE_UNSIGNED_URL
}
URL::URL (const URL& u) : url_(u.url_) {}
URL::~URL () {}

                                // assignment
URL&
URL::operator = (const URL& u)
{
  url_ = u.url_;
  return *this;
}

                                // conversions
                                // unescape the URL
URL::operator string () const
{
#if HAVE_UNSIGNED_URL
  convert<unsigned char,char> c (url_.c_str());
  cgi_url_unescape (c());
  return string (convert<char,unsigned char>(c()));
#else // HAVE_UNSIGNED_URL
  return string (cgi_url_unescape (c_string(url_.c_str())));
#endif // HAVE_UNSIGNED_URL
}

                                // inspectors
string
URL::operator () () const { return url_; }
};                              // namespace ClearSilver


#if HAVE_UNSIGNED_URL
template <typename Destination,typename Source>
inline
convert<Destination,Source>::convert (const Source * s) : s_()
{
  size_t len = 0;
  for (const Source * j = s; *j; ++j)
    ++len;
  s_ = static_cast<Destination*>(calloc(len+1, sizeof(Destination)));
  Destination * i = s_;
  while (*s)
    *i++ = *s++;
}

template <typename Destination,typename Source>
inline
convert<Destination,Source>::~convert () { free(s_); }

template <typename Destination,typename Source>
inline
convert<Destination,Source>::operator Destination * () const { return s_; }

template <typename Destination,typename Source>
inline
Destination * 
convert<Destination,Source>::operator () () const { return s_; }
#endif // HAVE_UNSIGNED_URL

---