URI.cpp

Go to the documentation of this file.

/*
  Copyright (C) 2008 National Institute For Space Research (INPE) - Brazil.

  This file is part of the TerraLib - a Framework for building GIS enabled applications.

  TerraLib is free software: you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation, either version 3 of the License,
  or (at your option) any later version.

  TerraLib is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  GNU Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with TerraLib. See COPYING. If not, write to
  TerraLib Team at <terralib-team@terralib.org>.
 */

/*!
  \file terralib/core/uri/URI.cpp

  \brief A class for representing an Uniform Resource Identifier (URI).

  \author Vinicius Campanha
  \author Gilberto Ribeiro de Queiroz
 */

// TerraLib
#include "URI.h"

// Boost
#include <boost/regex.hpp>

static const std::string regex_scheme = "(?<SCHEME_TYPE>[^\\]\\[:/?#@!$&'()*+,;=]+?):";

static const std::string regex_userInfo = "((?<USER_TYPE>.+):(?<PASSWORD_TYPE>.*)@)?";

static const std::string regex_host = "(?<HOST_TYPE>[^\\]\\[:/?#@!$&'()*+,;=]+)";

static const std::string regex_port = "(:(?<PORT_TYPE>[0-9]{1,5}))?";

static const std::string regex_path = "(?<PATH_TYPE>[^\\]\\[?#!$&'()*+,;=]+)?";

static const std::string regex_query = "(\\?(?<QUERY_TYPE>[^\\]\\[?#@!$'()*+,]+)?)?";

static const std::string regex_fragment = "(#(?<FRAGMENT_TYPE>.+))?";

struct te::core::URI::Impl
{
  std::string m_uri;
  boost::match_results< std::string::const_iterator > m_match;
  bool m_isValid;
};

te::core::URI::URI()
  : m_pimpl(new Impl)
{
  m_pimpl->m_isValid = false;
}

te::core::URI::URI(const std::string& uri)
  : m_pimpl(new Impl)
{
  m_pimpl->m_uri = uri;
  m_pimpl->m_isValid = false;
  parse();
}

te::core::URI::URI(const URI& other)
  :  m_pimpl(new Impl)
{
  m_pimpl->m_uri = other.m_pimpl->m_uri;
  parse();
}

te::core::URI::~URI() = default;

te::core::URI&
te::core::URI::operator=(const URI& other)
{
  URI(other).swap(*this);
  return *this;
}

const std::string&
te::core::URI::uri() const
{
  return m_pimpl->m_uri;
}

std::string te::core::URI::scheme() const
{
  return m_pimpl->m_match["SCHEME_TYPE"].str();
}

std::string te::core::URI::user() const
{
  return m_pimpl->m_match["USER_TYPE"].str();
}

std::string te::core::URI::password() const
{
  return m_pimpl->m_match["PASSWORD_TYPE"].str();
}

std::string te::core::URI::host() const
{
  return m_pimpl->m_match["HOST_TYPE"].str();
}

std::string te::core::URI::port() const
{
  return m_pimpl->m_match["PORT_TYPE"].str();
}

std::string te::core::URI::path() const
{
  return m_pimpl->m_match["PATH_TYPE"].str();
}

std::string te::core::URI::query() const
{
  return m_pimpl->m_match["QUERY_TYPE"].str();
}

std::string te::core::URI::fragment() const
{
  return m_pimpl->m_match["FRAGMENT_TYPE"].str();
}

bool te::core::URI::isValid() const
{
  return m_pimpl->m_isValid;
}

void
te::core::URI::swap(URI& other)
{
  std::swap(m_pimpl->m_uri, other.m_pimpl->m_uri);
  std::swap(m_pimpl->m_match, other.m_pimpl->m_match);
  std::swap(m_pimpl->m_isValid, other.m_pimpl->m_isValid);
}

void
te::core::URI::parse()
{
  m_pimpl->m_isValid = false;

  encode();

// first, let's try to match an URI with host
  boost::regex expression(regex_scheme + "//" + regex_userInfo + regex_host + regex_port + regex_path + regex_query + regex_fragment);

  boost::match_results< std::string::const_iterator > match;

// clear match results
  m_pimpl->m_match = match;

// is it a valid URI with host?
  if(boost::regex_match(m_pimpl->m_uri, match, expression, boost::match_default))
  {
    m_pimpl->m_isValid = true;
  }
  else
  {
// let's try to macth an URI without host!

    // Has empty groups to compensate the non used user, password and host groups
    boost::regex expression(regex_scheme + "/{0,2}((?<USER_TYPE>)(?<PASSWORD_TYPE>))(?<HOST_TYPE>)(?<PORT_TYPE>())" + regex_path + regex_query + regex_fragment);

    if(boost::regex_match(m_pimpl->m_uri, match, expression, boost::match_default))
      m_pimpl->m_isValid = true;
  }

  m_pimpl->m_match = match;
}

void
te::core::URI::encode()
{
  std::string temp;

  std::string::const_iterator it = std::begin(m_pimpl->m_uri);

  while(it != std::end(m_pimpl->m_uri))
  {
    int ASCIIvalue = *it;

    if(ASCIIvalue < 33 || ASCIIvalue > 126)
    {
      temp += '%';
      temp += hexToLetter((*it >> 4) & 0x0f);
      temp += hexToLetter(*it & 0x0f);
    }
    else
      temp += *it;

    it++;
  }

  m_pimpl->m_uri = temp;
}


std::string
te::core::URI::hexToLetter(int i)
{
  int ASCIIvalue = i;
  std::string value;

  switch (ASCIIvalue) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
    case 6:
    case 7:
    case 8:
    case 9:
    {
      value = ASCIIvalue + '0';
      return value;
    }
    case 10:
    case 11:
    case 12:
    case 13:
    case 14:
    default:
    {
      value = ASCIIvalue - 10 + 'A';
      return value;
    }
  }
  return std::string();
}