xpcom/string/nsTDependentSubstring.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsTDependentSubstring.h"
   8
   9 template <typename T>
  10 void nsTDependentSubstring<T>::Rebind(const substring_type& str,
  11                                       size_type startPos, size_type length) {
  12   // If we currently own a buffer, release it.
  13   this->Finalize();
  14
  15   size_type strLength = str.Length();
  16
  17   if (startPos > strLength) {
  18     startPos = strLength;
  19   }
  20
  21   char_type* newData =
  22       const_cast<char_type*>(static_cast<const char_type*>(str.Data())) +
  23       startPos;
  24   size_type newLength = XPCOM_MIN(length, strLength - startPos);
  25   DataFlags newDataFlags = DataFlags(0);
  26   this->SetData(newData, newLength, newDataFlags);
  27 }
  28
  29 template <typename T>
  30 void nsTDependentSubstring<T>::Rebind(const char_type* data, size_type length) {
  31   NS_ASSERTION(data, "nsTDependentSubstring must wrap a non-NULL buffer");
  32
  33   // If we currently own a buffer, release it.
  34   this->Finalize();
  35
  36   char_type* newData =
  37       const_cast<char_type*>(static_cast<const char_type*>(data));
  38   size_type newLength = length;
  39   DataFlags newDataFlags = DataFlags(0);
  40   this->SetData(newData, newLength, newDataFlags);
  41 }
  42
  43 template <typename T>
  44 void nsTDependentSubstring<T>::Rebind(const char_type* aStart,
  45                                       const char_type* aEnd) {
  46   MOZ_RELEASE_ASSERT(aStart <= aEnd, "Overflow!");
  47   this->Rebind(aStart, size_type(aEnd - aStart));
  48 }
  49
  50 template <typename T>
  51 nsTDependentSubstring<T>::nsTDependentSubstring(const char_type* aStart,
  52                                                 const char_type* aEnd)
  53     : substring_type(const_cast<char_type*>(aStart), aEnd - aStart,
  54                      DataFlags(0), ClassFlags(0)) {
  55   MOZ_RELEASE_ASSERT(aStart <= aEnd, "Overflow!");
  56 }
  57
  58 #if defined(MOZ_USE_CHAR16_WRAPPER)
  59 template <typename T>
  60 template <typename Q, typename EnableIfChar16>
  61 nsTDependentSubstring<T>::nsTDependentSubstring(char16ptr_t aStart,
  62                                                 char16ptr_t aEnd)
  63     : substring_type(static_cast<const char16_t*>(aStart),
  64                      static_cast<const char16_t*>(aEnd)) {
  65   MOZ_RELEASE_ASSERT(static_cast<const char16_t*>(aStart) <=
  66                          static_cast<const char16_t*>(aEnd),
  67                      "Overflow!");
  68 }
  69 #endif
  70
  71 template <typename T>
  72 nsTDependentSubstring<T>::nsTDependentSubstring(const const_iterator& aStart,
  73                                                 const const_iterator& aEnd)
  74     : substring_type(const_cast<char_type*>(aStart.get()),
  75                      aEnd.get() - aStart.get(), DataFlags(0), ClassFlags(0)) {
  76   MOZ_RELEASE_ASSERT(aStart.get() <= aEnd.get(), "Overflow!");
  77 }
  78
  79 template <typename T>
  80 const nsTDependentSubstring<T> Substring(const T* aStart, const T* aEnd) {
  81   MOZ_RELEASE_ASSERT(aStart <= aEnd, "Overflow!");
  82   return nsTDependentSubstring<T>(aStart, aEnd);
  83 }
  84
  85 template nsTDependentSubstring<char> const Substring<char>(char const*,
  86                                                            char const*);
  87 template nsTDependentSubstring<char16_t> const Substring<char16_t>(
  88     char16_t const*, char16_t const*);
  89
  90 #if defined(MOZ_USE_CHAR16_WRAPPER)
  91 const nsTDependentSubstring<char16_t> Substring(char16ptr_t aData,
  92                                                 size_t aLength) {
  93   return nsTDependentSubstring<char16_t>(aData, aLength);
  94 }
  95
  96 const nsTDependentSubstring<char16_t> Substring(char16ptr_t aStart,
  97                                                 char16ptr_t aEnd) {
  98   return Substring(static_cast<const char16_t*>(aStart),
  99                    static_cast<const char16_t*>(aEnd));
 100 }
 101 #endif