binding-cpp/runtime/include/util/EtchURL.h

/* $Id$
 *
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version
 * 2.0 (the "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __ETCHURL_H__
#define __ETCHURL_H__

#include "common/EtchString.h"
#include "common/EtchHashTable.h"
#include "common/EtchList.h"
#include "util/EtchUtil.h"
#include "common/EtchConfig.h"
#include "capu/os/StringUtils.h"

class EtchURL {
public:

  /**
   * Constructs an empty url.
   */
  EtchURL();

  /**
   * Constructs a url from a string
   * @param urlStr
   */
  EtchURL(const char * urlStr);

  /**
   * Constructs a url from a string.
   * @param urlStr
   */
  EtchURL(const EtchString& urlStr);

  /**
   * Deconstructor
   */
  virtual ~EtchURL();

  /**
   * @return the scheme.
   */
  EtchString& getScheme();

  /**
   * Sets the scheme.
   *
   * @param scheme the scheme to set which may be null but not blank.
   */
  void setScheme(const EtchString& scheme);

  /**
   * Sets the scheme.
   *
   * @param scheme the scheme to set which may be null but not blank.
   */
  status_t setScheme(EtchString* scheme);

  /**
   * Tests the scheme for a match. The schemes are case-insensitive.
   *
   * @param testScheme a scheme to test against.
   *
   * @return true if the schemes match, false otherwise.
   */
  capu::bool_t isScheme(EtchString& testScheme);

  //////////
  // USER //
  //////////

  /**
   * @return the user.
   */
  EtchString& getUser();

  /**
   * Sets the user.
   *
   * @param user the user to set which may be null but not blank.
   */
  void setUser(const EtchString& user);

  //////////////
  // PASSWORD //
  //////////////

  /**
   * @return the password.
   */
  EtchString& getPassword();

  /**
   * Sets the password.
   *
   * @param password the password to set which may be null but not blank.
   */
  void setPassword(const EtchString& password);

  //////////
  // HOST //
  //////////

  /**
   * @return the host.
   */
  EtchString& getHost();

  /**
   * Sets the host.
   *
   * @param host the host to set which may be null but not blank.
   */
  void setHost(const EtchString& host);

  //////////
  // PORT //
  //////////

  /**
   * @return true if a port has been specified, false otherwise.
   */
  capu::bool_t hasPort();

  /**
   * @return the port. Null if no port has been specified.
   */
  capu::uint16_t getPort();

  /**
   * Sets the port.
   *
   * @param port the port to set which may be between 0 and 65535.
   */
  void setPort(capu::uint16_t port);

  /////////
  // URI //
  /////////

  /**
   * @return the uri.
   */
  EtchString& getUri();

  /**
   * Sets the uri.
   *
   * @param uri the uri to set which may be null or blank.
   */
  void setUri(const EtchString& uri);

  ////////////
  // PARAMS //
  ////////////

  /**
   * @return true if there is at least one param.
   */
  capu::bool_t hasParams();

  /**
   * Adds a param to the list of params for this url. Only the unique
   * params are maintained. Duplicate param values are suppressed.
   *
   * @param param a param (e.g., "transport=tcp" or "01831864574898475").
   */
  void addParam(EtchString& param);

  /**
   * Removes all the params.
   */
  void clearParams();

  /////////////////
  // QUERY TERMS //
  /////////////////

  /**
   * Adds the specified query term to the list of query terms. Duplicate
   * name/value pairs are suppressed.
   * @param name
   * @param value
   * @return ETCH_EINVAL if the parameters are NULL
   *         ETCH_OK if term is successfully added
   *         ETCH_ENO_MEMORY if allocation of term is failed
   */
  status_t addTerm(EtchString& name, EtchString& value);

  /**
   * Adds the specified query term to the list of query terms. Duplicate
   * name/value pairs are suppressed.
   * @param name
   * @param value
   * @return ETCH_EINVAL if the parameters are NULL
   *         ETCH_OK if term is successfully added
   *         ETCH_ENO_MEMORY if allocation of term is failed
   */
  status_t addTerm(EtchString& name, capu::int32_t value);

  /**
   * Adds the specified query term to the list of query terms. Duplicate
   * name/value pairs are suppressed.
   * @param name
   * @param value
   * @return ETCH_EINVAL if the parameters are NULL
   *         ETCH_OK if term is successfully added
   *         ETCH_ENO_MEMORY if allocation of term is failed
   */
  status_t addTerm(EtchString& name, capu::double_t value);

  /**
   * Adds the specified query term to the list of query terms. Duplicate
   * name/value pairs are suppressed.
   * @param name
   * @param value
   * @return ETCH_EINVAL if the parameters are NULL
   *         ETCH_OK if term is successfully added
   *         ETCH_ENO_MEMORY if allocation of term is failed
   */
  status_t addTerm(EtchString& name, capu::bool_t value);

  /**
   * Removes all the query terms.
   */
  void clearTerms();


  //////////////
  // FRAGMENT //
  //////////////

  /**
   * @return the fragment.
   */
  EtchString& getFragment();

  /**
   * Sets the fragment.
   *
   * @param fragment the fragment to set which may be null but not blank.
   */
  void setFragment(EtchString& fragment);

  /**
   *
   * @return list of parameters
   */
  EtchList<EtchString>& getParams();

  /**
   *
   * @return hash table which composed of terms
   */
  EtchHashTable<EtchString, EtchString>& getTerms();

private:

  EtchString scheme;
  EtchString user;
  EtchString password;
  EtchString host;
  capu::uint16_t port;
  EtchString uri;
  EtchString fragment;
  EtchList<EtchString> params;
  EtchHashTable<EtchString, EtchString> terms;

  status_t parse(const EtchString* s);

  status_t parseHost(const EtchString* s);

  status_t parseUserPassword(const EtchString* s);

  status_t parseHostPort(const EtchString* s);

  status_t parseParams(const EtchString* s);

  status_t parseTerms(const EtchString* s);

  status_t parseTerm(const EtchString *s);

};

#endif