XrdClURL.hh

Go to the documentation of this file.

//------------------------------------------------------------------------------
// Copyright (c) 2011-2012 by European Organization for Nuclear Research (CERN)
// Author: Lukasz Janyst <ljanyst@cern.ch>
//------------------------------------------------------------------------------
// XRootD 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.
//
// XRootD 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 General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//------------------------------------------------------------------------------

#ifndef __XRD_CL_URL_HH__
#define __XRD_CL_URL_HH__

#include <string>
#include <map>

namespace XrdCl
{
  //----------------------------------------------------------------------------
  //----------------------------------------------------------------------------
  class URL
  {
    public:
      typedef std::map<std::string, std::string> ParamsMap; 

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      URL();

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      URL( const std::string &url );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsValid() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsMetalink() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool IsLocalFile() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetURL() const
      {
        return pURL;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetHostId() const
      {
        return pHostId;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetLocation() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetProtocol() const
      {
        return pProtocol;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetProtocol( const std::string &protocol )
      {
        pProtocol = protocol;
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetUserName() const
      {
        return pUserName;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetUserName( const std::string &userName )
      {
        pUserName = userName;
        ComputeHostId();
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetPassword() const
      {
        return pPassword;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetPassword( const std::string &password )
      {
        pPassword = password;
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetHostName() const
      {
        return pHostName;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetHostName( const std::string &hostName )
      {
        pHostName = hostName;
        ComputeHostId();
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      int GetPort() const
      {
        return pPort;
      }

      //------------------------------------------------------------------------
      // Set port
      //------------------------------------------------------------------------
      void SetPort( int port )
      {
        pPort = port;
        ComputeHostId();
        ComputeURL();
      }

      //------------------------------------------------------------------------
      // Set host and port
      //------------------------------------------------------------------------
      void SetHostPort( const std::string &hostName, int port )
      {
        pHostName = hostName;
        pPort     = port;
        ComputeHostId();
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const std::string &GetPath() const
      {
        return pPath;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetPath( const std::string &path )
      {
        pPath = path;
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetPathWithParams() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetPathWithFilteredParams() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      const ParamsMap &GetParams() const
      {
        return pParams;
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetParamsAsString() const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      std::string GetParamsAsString( bool filter ) const;

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetParams( const std::string &params );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void SetParams( const ParamsMap &params )
      {
        pParams = params;
        ComputeURL();
      }

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      bool FromString( const std::string &url );

      //------------------------------------------------------------------------
      //------------------------------------------------------------------------
      void Clear();

    private:
      bool ParseHostInfo( const std::string hhostInfo );
      bool ParsePath( const std::string &path );
      void ComputeHostId();
      void ComputeURL();
      bool PathEndsWith( const std::string & sufix ) const;
      std::string pHostId;
      std::string pProtocol;
      std::string pUserName;
      std::string pPassword;
      std::string pHostName;
      int         pPort;
      std::string pPath;
      ParamsMap   pParams;
      std::string pURL;

  };
}

#endif // __XRD_CL_URL_HH__