sbStringUtils.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 :miv */
/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2010 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

#ifndef __SBSTRINGUTILS_H__
#define __SBSTRINGUTILS_H__

#include <nsStringAPI.h>
#include <nsTArray.h>
#include <prprf.h>
#include <sbMemoryUtils.h>

class nsIStringEnumerator;

class sbAutoString : public nsAutoString
{
public:
  sbAutoString(const char* aValue)
  {
    AssignLiteral(aValue);
  }

  sbAutoString(int aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%d", aValue);
    AssignLiteral(valueStr);
  }

  sbAutoString(PRUint32 aValue,
               PRBool aHex = PR_FALSE,
               PRBool aHexPrefix = PR_TRUE)
  {
    char valueStr[64];

    if(!aHex) {
      PR_snprintf(valueStr, sizeof(valueStr), "%lu", long(aValue));
    }
    else {
      if(aHexPrefix) {
        PR_snprintf(valueStr, sizeof(valueStr), "0x%lx", long(aValue));
      }
      else {
        PR_snprintf(valueStr, sizeof(valueStr), "%lx", long(aValue));
      }
    }

    AssignLiteral(valueStr);
  }

  sbAutoString(PRInt64 aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%lld", aValue);
    AssignLiteral(valueStr);
  }

  sbAutoString(PRUint64 aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%llu", aValue);
    AssignLiteral(valueStr);
  }

  sbAutoString(nsID* aValue)
  {
    char idString[NSID_LENGTH];
    aValue->ToProvidedString(idString);
    AssignLiteral(idString);
  }
};

class sbCAutoString : public nsCAutoString
{
public:
  sbCAutoString(const char* aValue)
  {
    AssignLiteral(aValue);
  }

  sbCAutoString(int aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%d", aValue);
    AssignLiteral(valueStr);
  }

  sbCAutoString(PRUint32 aValue,
                PRBool aHex = PR_FALSE,
                PRBool aHexPrefix = PR_TRUE)
  {
    char valueStr[64];

    if(!aHex) {
      PR_snprintf(valueStr, sizeof(valueStr), "%lu", long(aValue));
    }
    else {
      if(aHexPrefix) {
        PR_snprintf(valueStr, sizeof(valueStr), "0x%lx", long(aValue));
      }
      else {
        PR_snprintf(valueStr, sizeof(valueStr), "%lx", long(aValue));
      }
    }

    AssignLiteral(valueStr);
  }

  sbCAutoString(PRInt64 aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%lld", aValue);
    AssignLiteral(valueStr);
  }

  sbCAutoString(PRUint64 aValue)
  {
    char valueStr[64];

    PR_snprintf(valueStr, sizeof(valueStr), "%llu", aValue);
    AssignLiteral(valueStr);
  }

  sbCAutoString(nsID* aValue)
  {
    char idString[NSID_LENGTH];
    aValue->ToProvidedString(idString);
    AssignLiteral(idString);
  }
};

class SBVoidString : public nsString
{
public:
  SBVoidString()
  {
    SetIsVoid(PR_TRUE);
  }
};

class SBVoidCString : public nsCString
{
public:
  SBVoidCString()
  {
    SetIsVoid(PR_TRUE);
  }
};
PRInt32 nsString_FindCharInSet(const nsAString& aString,
                               const char *aPattern,
                               PRInt32 aOffset = 0);

void AppendInt(nsAString& str, PRUint64 val);

PRInt64 nsString_ToInt64(const nsAString& str, nsresult* rv = nsnull);

PRUint64 nsString_ToUint64(const nsAString& str, nsresult* rv = nsnull);

void SB_CompressWhitespace(nsAString& aString,
                           PRBool aLeading = PR_TRUE,
                           PRBool aTrailing = PR_TRUE);

nsresult SB_StringEnumeratorEquals(nsIStringEnumerator* aLeft,
                                   nsIStringEnumerator* aRight,
                                   PRBool* _retval);

void nsString_ReplaceChar(/* inout */ nsAString& aString,
                          const nsAString& aOldChars,
                          const PRUnichar aNewChar);

void
nsCString_ReplaceChars(nsACString& aOldString,
                       const nsACString& aOldChars,
                       const char aNewChar);

void nsString_ReplaceSubstring(/* inout */ nsAString &aString,
                               const nsAString &aOldString,
                               const nsAString &aNewString);

PRBool IsLikelyUTF8(const nsACString& aString);

PRBool IsUTF8(const nsACString& aString);

void nsString_Split(const nsAString&    aString,
                    const nsAString&    aDelimiter,
                    nsTArray<nsString>& aSubStringArray);

void nsCString_Split(const nsACString&    aString,
                     const nsACString&    aDelimiter,
                     nsTArray<nsCString>& aSubStringArray);

nsString SB_FormatISO8601TimeString(PRTime aTime);

nsresult SB_ParseISO8601TimeString(const nsAString& aISO8601TimeString,
                                   PRTime*          aTime);

/*
 * Songbird string bundle URL.
 */
#define SB_STRING_BUNDLE_URL "chrome://songbird/locale/songbird.properties"

nsresult SBGetLocalizedString(nsAString&             aString,
                              const nsAString&       aKey,
                              const nsAString&       aDefault,
                              class nsIStringBundle* aStringBundle = nsnull);

nsresult SBGetLocalizedString(nsAString&       aString,
                              const nsAString& aKey);

nsresult SBGetLocalizedString(nsAString&             aString,
                              const char*            aKey,
                              const char*            aDefault = nsnull,
                              class nsIStringBundle* aStringBundle = nsnull);

nsresult SBGetLocalizedFormattedString(nsAString&                aString,
                                       const nsAString&          aKey,
                                       const nsTArray<nsString>& aParams,
                                       const nsAString&          aDefault,
                                       class nsIStringBundle*    aStringBundle);

class SBLocalizedString : public nsString
{
public:
  SBLocalizedString(const nsAString&       aKey,
                    const nsAString&       aDefault,
                    class nsIStringBundle* aStringBundle = nsnull)
  {
    nsString stringValue;
    SBGetLocalizedString(stringValue, aKey, aDefault, aStringBundle);
    Assign(stringValue);
  }

  SBLocalizedString(const nsAString& aKey)
  {
    nsString stringValue;
    SBGetLocalizedString(stringValue, aKey);
    Assign(stringValue);
  }

  SBLocalizedString(const char*            aKey,
                    const char*            aDefault = nsnull,
                    class nsIStringBundle* aStringBundle = nsnull)
  {
    nsString stringValue;
    SBGetLocalizedString(stringValue, aKey, aDefault, aStringBundle);
    Assign(stringValue);
  }

  SBLocalizedString(const char*               aKey,
                    const nsTArray<nsString>& aParams,
                    const char*               aDefault = nsnull,
                    class nsIStringBundle*    aStringBundle = nsnull)
  {
    // Get the key and default arguments.
    nsString key;
    key.AssignLiteral(aKey);
    nsString _default;
    if (aDefault)
      _default.AssignLiteral(aDefault);
    else
      _default.SetIsVoid(PR_TRUE);

    // Set string value.
    nsString stringValue;
    SBGetLocalizedFormattedString(stringValue,
                                  key,
                                  aParams,
                                  _default,
                                  aStringBundle);
    Assign(stringValue);
  }

  SBLocalizedString(const nsAString&          aKey,
                    const nsTArray<nsString>& aParams,
                    const nsAString&          aDefault,
                    class nsIStringBundle*    aStringBundle = nsnull)
  {
    nsString stringValue;
    SBGetLocalizedFormattedString(stringValue,
                                  aKey,
                                  aParams,
                                  aDefault,
                                  aStringBundle);
    Assign(stringValue);
  }
};

template <class T>
inline
T const & sbAppendStringArrayDefaultExtractor(T const & aArrayItem)
{
  return aArrayItem;
}

template <class S, class Sep, class T, class E>
inline
S sbAppendStringArray(S & aTarget,
                      Sep const & aSeparator,
                      T const & aStringArray,
                      E aExtractor)
{
  // Save off the lengths
  PRUint32 const separatorLength = aSeparator.Length();
  PRUint32 const stringLength = aTarget.Length();
  PRUint32 const length = aStringArray.Length();

  // Calc the final length from the original string + length of all the
  // separators
  PRUint32 finalLength = stringLength + (separatorLength * (aStringArray.Length() - 1));
  for (PRUint32 index = 0; index < length; ++index) {
    finalLength += aStringArray[index].Length();
  }
  typename S::char_type const * const separator = aSeparator.BeginReading();
  // Set the writePosition to the end of the string
  typename S::char_type * writePosition;
  typename S::char_type * endPosition;
  aTarget.BeginWriting(&writePosition, &endPosition, finalLength);
  if (!writePosition)
    return aTarget;
  writePosition += stringLength;
  // Now append
  PRBool const isSeparatorEmpty = aSeparator.IsEmpty();
  for (PRUint32 index = 0; index < length; ++index) {
    if (index != 0 && !isSeparatorEmpty) {
      memcpy(writePosition, separator, separatorLength * sizeof(typename S::char_type));
      writePosition += separatorLength;
    }
    S const & value = aExtractor(aStringArray[index]);
    memcpy(writePosition,
           value.BeginReading(),
           value.Length() * sizeof(typename S::char_type));
    writePosition += value.Length();
  }
  return aTarget;
}

template <class S, class Sep, class T>
inline
S sbAppendStringArray(S & aTarget,
                      Sep const & aSeparator,
                      T const & aStringArray)
{
  return sbAppendStringArray(aTarget, aSeparator, aStringArray, sbAppendStringArrayDefaultExtractor<S>);
}


template <class StringType, class EnumeratorType>
inline nsresult
sbAppendStringEnumerator(StringType&     aStringArray,
                         EnumeratorType* aEnumerator)
{
  NS_ENSURE_ARG_POINTER(aEnumerator);

  // Append all elements from the enumerator.
  nsresult rv;
  while (1) {
    // Check if the enumerator has any more elements.
    PRBool hasMore;
    rv = aEnumerator->HasMore(&hasMore);
    NS_ENSURE_SUCCESS(rv, rv);
    if (!hasMore)
      break;

    // Append the enumerator element to the array.
    typename StringType::elem_type stringElement;
    rv = aEnumerator->GetNext(stringElement);
    NS_ENSURE_SUCCESS(rv, rv);
    NS_ENSURE_TRUE(aStringArray.AppendElement(stringElement),
                   NS_ERROR_OUT_OF_MEMORY);
  }

  return NS_OK;
}

//
// Auto-disposal class wrappers.
//
//   sbAutoSmprintf             Wrapper to auto-free strings created by
//                              smprintf.
//

SB_AUTO_NULL_CLASS(sbAutoSmprintf, char*, PR_smprintf_free(mValue));

template <class T>
T sbEscapeXML(T const & aSrc)
{
  T result;
  typename T::char_type const * src;
  typename T::char_type const * srcEnd;
  aSrc.BeginReading(&src, &srcEnd);

  typename T::char_type * destStart;
  typename T::char_type * destEnd;
  result.BeginWriting(&destStart, &destEnd, (aSrc.Length() * 6 + 1));
  typename T::char_type * dest = destStart;

  while (src != srcEnd) {
    const char c = *src++;
    // Escape the character if needed
    switch (c) {
      case '<':
        *dest++ = '&';
        *dest++ = 'l';
        *dest++ = 't';
        *dest++ = ';';
      break;
      case '>':
        *dest++ = '&';
        *dest++ = 'g';
        *dest++ = 't';
        *dest++ = ';';
      break;
      case '&':
        *dest++ = '&';
        *dest++ = 'a';
        *dest++ = 'm';
        *dest++ = 'p';
        *dest++ = ';';
      break;
      case '"':
        *dest++ = '&';
        *dest++ = 'q';
        *dest++ = 'u';
        *dest++ = 'o';
        *dest++ = 't';
        *dest++ = ';';
      break;
      case '\'':
        *dest++ = '&';
        *dest++ = '#';
        *dest++ = '3';
        *dest++ = '9';
        *dest++ = ';';
      break;
      default:
        *dest++ = c;
      break;
    }
  }

  result.SetLength(dest - destStart);
  return result;
}

#endif /* __SBSTRINGUTILS_H__ */