vtkUnicodeString.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkUnicodeString.h
 
-------------------------------------------------------------------------
  Copyright 2008 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
 
#ifndef vtkUnicodeString_h
#define vtkUnicodeString_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkDeprecation.h"
#include "vtkSystemIncludes.h"
#include <string>
#include <vector>
 
class vtkUnicodeString;
 
typedef vtkTypeUInt32 vtkUnicodeStringValueType;
 
//
// The following should be eventually placed in vtkSetGet.h
//
 
// This is same as extra extended template macro with an
// additional case for VTK_UNICODE_STRING
#define vtkSuperExtraExtendedTemplateMacro(call)                                                   \
  vtkExtraExtendedTemplateMacro(call);                                                             \
  vtkTemplateMacroCase(VTK_UNICODE_STRING, vtkUnicodeString, call)
 
class vtkUnicodeString;
 
VTKCOMMONCORE_EXPORT bool operator==(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
VTKCOMMONCORE_EXPORT bool operator!=(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
VTKCOMMONCORE_EXPORT bool operator<(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
VTKCOMMONCORE_EXPORT bool operator<=(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
VTKCOMMONCORE_EXPORT bool operator>=(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
VTKCOMMONCORE_EXPORT bool operator>(const vtkUnicodeString& lhs, const vtkUnicodeString& rhs);
 
class VTKCOMMONCORE_EXPORT vtkUnicodeString
{
public:
  typedef vtkUnicodeStringValueType value_type;
  typedef std::string::size_type size_type;
 
  class VTKCOMMONCORE_EXPORT const_iterator
  {
  public:
    typedef std::bidirectional_iterator_tag iterator_category;
    typedef vtkUnicodeStringValueType value_type;
    typedef std::string::difference_type difference_type;
    typedef value_type* pointer;
    typedef value_type& reference;
 
    const_iterator();
 
    value_type operator*() const;
    bool operator==(const const_iterator&) const;
    bool operator!=(const const_iterator&) const;
    const_iterator& operator++();
    const_iterator operator++(int);
    const_iterator& operator--();
    const_iterator operator--(int);
 
  private:
    const_iterator(std::string::const_iterator);
    friend class vtkUnicodeString;
    std::string::const_iterator Position;
  };
 
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  vtkUnicodeString();
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  vtkUnicodeString(const vtkUnicodeString&);
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  vtkUnicodeString(size_type count, value_type character);
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  vtkUnicodeString(const_iterator begin, const_iterator end);
 
 
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static bool is_utf8(const char*);
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static bool is_utf8(const std::string&);
 
 
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static vtkUnicodeString from_utf8(const char*);
  // Constructs a string from a half-open sequence of UTF-8 encoded characters.
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static vtkUnicodeString from_utf8(const char* begin, const char* end);
  // Constructs a string from a sequence of UTF-8 encoded characters.
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static vtkUnicodeString from_utf8(const std::string&);
 
  VTK_DEPRECATED_IN_9_1_0("Use std::string instead.")
  static vtkUnicodeString from_utf16(const vtkTypeUInt16*);
 
  vtkUnicodeString& operator=(const vtkUnicodeString&);
 
  const_iterator begin() const;
  const_iterator end() const;
 
  value_type at(size_type offset) const;
  value_type operator[](size_type offset) const;
 
  const char* utf8_str() const;
  void utf8_str(std::string& result) const;
  std::vector<vtkTypeUInt16> utf16_str() const;
  void utf16_str(std::vector<vtkTypeUInt16>& result) const;
 
  size_type byte_count() const;
  size_type character_count() const;
  bool empty() const;
 
  static const size_type npos;
 
  vtkUnicodeString& operator+=(value_type);
  vtkUnicodeString& operator+=(const vtkUnicodeString& rhs);
 
  void push_back(value_type);
 
 
  void append(const vtkUnicodeString& value);
  void append(size_type count, value_type character);
  void append(const_iterator begin, const_iterator end);
 
 
  void assign(const vtkUnicodeString& value);
  void assign(size_type count, value_type character);
  void assign(const_iterator begin, const_iterator end);
 
  void clear();
 
  vtkUnicodeString fold_case() const;
 
  int compare(const vtkUnicodeString&) const;
 
  vtkUnicodeString substr(size_type offset = 0, size_type count = npos) const;
 
  void swap(vtkUnicodeString&);
 
private:
  std::string Storage;
  class back_insert_iterator;
};
 
#endif
 
// VTK-HeaderTest-Exclude: vtkUnicodeString.h