vtkURI.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkURI_h
#define vtkURI_h
 
#include "vtkIOCoreModule.h" // For export macro
#include "vtkObject.h"
#include "vtkSmartPointer.h"  // For vtkSmartPointer
#include "vtkWrappingHints.h" // For VTK_WRAPEXCLUDE
 
#include <cstdlib> // for std::size_t
#include <memory>  // for std::unique_ptr
#include <string>  // for std::string
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKIOCORE_EXPORT vtkURIComponent
{
public:
  struct UndefinedTag
  {
  };
  static constexpr UndefinedTag Undefined{};
 
  vtkURIComponent() = default;
 
  vtkURIComponent(std::string str)
    : Value{ std::move(str) }
    , Defined{ true }
  {
  }
 
  vtkURIComponent(const char* str)
    : Value{ str }
    , Defined{ true }
  {
  }
 
  vtkURIComponent(UndefinedTag) {}
 
  ~vtkURIComponent() = default;
  vtkURIComponent(const vtkURIComponent&) = default;
  vtkURIComponent& operator=(const vtkURIComponent&) = default;
  vtkURIComponent(vtkURIComponent&&) = default;
  vtkURIComponent& operator=(vtkURIComponent&&) = default;
 
  const std::string& GetValue() const noexcept { return this->Value; }
 
  bool IsDefined() const noexcept { return this->Defined; }
 
  explicit operator bool() const noexcept { return this->Defined; }
 
 
  bool operator==(const vtkURIComponent& other) const noexcept
  {
    return this->Value == other.Value && this->Defined == other.Defined;
  }
 
  bool operator!=(const vtkURIComponent& other) const noexcept { return !(*this == other); }
 
private:
  std::string Value;
  bool Defined = false;
};
 
class VTKIOCORE_EXPORT vtkURI final : public vtkObject
{
public:
  vtkTypeMacro(vtkURI, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  static vtkURI* New();
 
  static std::string PercentEncode(const std::string& str)
  {
    return PercentEncode(str.data(), str.size());
  }
 
  static std::string PercentEncode(const char* str, std::size_t size);
 
  static std::string PercentDecode(const std::string& str)
  {
    return PercentDecode(str.data(), str.size());
  }
 
  static std::string PercentDecode(const char* str, std::size_t size);
 
  VTK_WRAPEXCLUDE static vtkSmartPointer<vtkURI> Make(
    vtkURIComponent scheme = vtkURIComponent::Undefined,
    vtkURIComponent authority = vtkURIComponent::Undefined, vtkURIComponent path = "",
    vtkURIComponent query = vtkURIComponent::Undefined,
    vtkURIComponent fragment = vtkURIComponent::Undefined);
 
  static vtkSmartPointer<vtkURI> Clone(const vtkURI* other);
 
  static vtkSmartPointer<vtkURI> Parse(const std::string& uri)
  {
    return Parse(uri.data(), uri.size());
  }
 
  static vtkSmartPointer<vtkURI> Parse(const char* uri, std::size_t size);
 
  static vtkSmartPointer<vtkURI> Resolve(const vtkURI* baseURI, const vtkURI* uri);
 
  const vtkURIComponent& GetScheme() const { return this->Scheme; }
 
  const vtkURIComponent& GetAuthority() const { return this->Authority; }
 
  const vtkURIComponent& GetPath() const { return this->Path; }
 
  const vtkURIComponent& GetQuery() const { return this->Query; }
 
  const vtkURIComponent& GetFragment() const { return this->Fragment; }
 
 
  bool IsReference() const { return this->IsRelative() || this->IsFull(); }
 
  bool IsRelative() const { return !this->Scheme; }
 
  bool IsAbsolute() const { return this->Scheme && !this->Fragment; }
 
  bool IsFull() const { return this->Scheme.IsDefined(); }
 
  bool IsSameDocRef() const
  {
    return !this->Scheme && !this->Authority && this->Path.GetValue().empty() && !this->Query &&
      this->Fragment;
  }
 
  bool IsEmpty() const
  {
    return !this->Scheme && !this->Authority && this->Path.GetValue().empty() && !this->Query &&
      !this->Fragment;
  }
 
  vtkSmartPointer<vtkURI> Clone() const { return vtkURI::Clone(this); }
 
  std::string ToString() const;
 
private:
  static vtkSmartPointer<vtkURI> MakeUnchecked(vtkURIComponent scheme, vtkURIComponent authority,
    vtkURIComponent path, vtkURIComponent query, vtkURIComponent fragment);
 
  // These functions are factories and need write access to this class
  friend vtkSmartPointer<vtkURI> MakeUnchecked(vtkURIComponent scheme, vtkURIComponent authority,
    vtkURIComponent path, vtkURIComponent query, vtkURIComponent fragment);
  friend vtkSmartPointer<vtkURI> Clone(const vtkURI* other);
 
  vtkURI() = default;
  ~vtkURI() override = default;
  vtkURI(const vtkURI&) = delete;
  vtkURI& operator=(const vtkURI&) = delete;
 
  vtkURIComponent Scheme{};
  vtkURIComponent Authority{};
  vtkURIComponent Path{ "" }; // path is defined but empty by default
  vtkURIComponent Query{};
  vtkURIComponent Fragment{};
};
 
VTK_ABI_NAMESPACE_END
 
#endif