[stdstring] get rid of CStdString in playlists/

diff --git a/xbmc/PartyModeManager.cpp b/xbmc/PartyModeManager.cpp
index 41c6d31..5348c74 100644 (file)
--- a/xbmc/PartyModeManager.cpp
+++ b/xbmc/PartyModeManager.cpp
@@ -113,7 +113,7 @@ bool CPartyModeManager::Enable(PartyModeContext context /*= PARTYMODECONTEXT_MUS
     CMusicDatabase db;
     if (db.Open())
     {
-      set<CStdString> playlists;
+      set<std::string> playlists;
       if ( playlistLoaded )
         m_strCurrentFilterMusic = playlist.GetWhereClause(db, playlists);
 
@@ -142,7 +142,7 @@ bool CPartyModeManager::Enable(PartyModeContext context /*= PARTYMODECONTEXT_MUS
     CVideoDatabase db;
     if (db.Open())
     {
-      set<CStdString> playlists;
+      set<std::string> playlists;
       if ( playlistLoaded )
         m_strCurrentFilterVideo = playlist.GetWhereClause(db, playlists);
 

diff --git a/xbmc/dialogs/GUIDialogMediaFilter.cpp b/xbmc/dialogs/GUIDialogMediaFilter.cpp
index a1063e5..329cf9b 100644 (file)
--- a/xbmc/dialogs/GUIDialogMediaFilter.cpp
+++ b/xbmc/dialogs/GUIDialogMediaFilter.cpp
@@ -633,7 +633,7 @@ int CGUIDialogMediaFilter::GetItems(const Filter &filter, std::vector<std::strin
     if (!videodb.Open())
       return -1;
 
-    std::set<CStdString> playlists;
+    std::set<std::string> playlists;
     CDatabase::Filter dbfilter;
     dbfilter.where = tmpFilter.GetWhereClause(videodb, playlists);
 
@@ -664,7 +664,7 @@ int CGUIDialogMediaFilter::GetItems(const Filter &filter, std::vector<std::strin
     if (!musicdb.Open())
       return -1;
 
-    std::set<CStdString> playlists;
+    std::set<std::string> playlists;
     CDatabase::Filter dbfilter;
     dbfilter.where = tmpFilter.GetWhereClause(musicdb, playlists);
     

diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp
index da20ed0..a3d46ad 100644 (file)
--- a/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistEditor.cpp
@@ -324,7 +324,7 @@ void CGUIDialogSmartPlaylistEditor::UpdateButtons()
   // setup groups
   labels.clear();
   vector<Field> groups = CSmartPlaylistRule::GetGroups(m_playlist.GetType());
-  Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup());
+  Field currentGroup = CSmartPlaylistRule::TranslateGroup(m_playlist.GetGroup().c_str());
   for (unsigned int i = 0; i < groups.size(); i++)
     labels.push_back(make_pair(CSmartPlaylistRule::GetLocalizedGroup(groups[i]), groups[i]));
   SET_CONTROL_LABELS(CONTROL_GROUP_BY, currentGroup, &labels);

diff --git a/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp b/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp
index 2dfabd3..f3a8234 100644 (file)
--- a/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp
+++ b/xbmc/dialogs/GUIDialogSmartPlaylistRule.cpp
@@ -264,7 +264,7 @@ void CGUIDialogSmartPlaylistRule::OnBrowse()
       CSmartPlaylist playlist;
       // don't list unloadable smartplaylists or any referencable smartplaylists
       // which do not match the type of the current smartplaylist
-      if (!playlist.Load((CStdString)item->GetPath()) ||
+      if (!playlist.Load(item->GetPath()) ||
          (m_rule.m_field == FieldPlaylist &&
          (!CSmartPlaylist::CheckTypeCompatibility(m_type, playlist.GetType()) ||
          (!playlist.GetGroup().empty() || playlist.IsGroupMixed()))))

diff --git a/xbmc/filesystem/SmartPlaylistDirectory.cpp b/xbmc/filesystem/SmartPlaylistDirectory.cpp
index cc3b7ec..8ca7970 100644 (file)
--- a/xbmc/filesystem/SmartPlaylistDirectory.cpp
+++ b/xbmc/filesystem/SmartPlaylistDirectory.cpp
@@ -65,7 +65,7 @@ namespace XFILE
   bool CSmartPlaylistDirectory::GetDirectory(const CSmartPlaylist &playlist, CFileItemList& items, const CStdString &strBaseDir /* = "" */, bool filter /* = false */)
   {
     bool success = false, success2 = false;
-    std::vector<CStdString> virtualFolders;
+    std::vector<std::string> virtualFolders;
 
     SortDescription sorting;
     sorting.limitEnd = playlist.GetLimit();
@@ -82,7 +82,7 @@ namespace XFILE
 
     // get all virtual folders and add them to the item list
     playlist.GetVirtualFolders(virtualFolders);
-    for (std::vector<CStdString>::const_iterator virtualFolder = virtualFolders.begin(); virtualFolder != virtualFolders.end(); virtualFolder++)
+    for (std::vector<std::string>::const_iterator virtualFolder = virtualFolders.begin(); virtualFolder != virtualFolders.end(); virtualFolder++)
     {
       CFileItemPtr pItem = CFileItemPtr(new CFileItem(*virtualFolder, true));
       IFileDirectory *dir = CFileDirectoryFactory::Create(pItem->GetURL(), pItem.get());
@@ -95,9 +95,9 @@ namespace XFILE
       }
     }
 
-    if (playlist.GetType().Equals("movies") ||
-        playlist.GetType().Equals("tvshows") ||
-        playlist.GetType().Equals("episodes"))
+    if (playlist.GetType() == "movies" ||
+        playlist.GetType() == "tvshows" ||
+        playlist.GetType() == "episodes")
     {
       CVideoDatabase db;
       if (db.Open())
@@ -158,7 +158,7 @@ namespace XFILE
       if (db.Open())
       {
         CSmartPlaylist plist(playlist);
-        if (playlist.GetType().Equals("mixed") || playlist.GetType().empty())
+        if (playlist.GetType() == "mixed" || playlist.GetType().empty())
           plist.SetType("songs");
 
         MediaType mediaType = MediaTypes::FromString(plist.GetType());
@@ -209,13 +209,13 @@ namespace XFILE
       }
     }
 
-    if (playlist.GetType().Equals("musicvideos") || playlist.GetType().Equals("mixed"))
+    if (playlist.GetType() == "musicvideos" || playlist.GetType() == "mixed")
     {
       CVideoDatabase db;
       if (db.Open())
       {
         CSmartPlaylist mvidPlaylist(playlist);
-        if (playlist.GetType().Equals("mixed"))
+        if (playlist.GetType() == "mixed")
           mvidPlaylist.SetType("musicvideos");
 
         CStdString baseDir = strBaseDir;
@@ -292,9 +292,9 @@ namespace XFILE
       item->m_iprogramCount = i;  // hack for playlist order
     }
 
-    if (playlist.GetType().Equals("mixed"))
+    if (playlist.GetType() == "mixed")
       return success || success2;
-    else if (playlist.GetType().Equals("musicvideos"))
+    else if (playlist.GetType() == "musicvideos")
       return success2;
     else
       return success;

diff --git a/xbmc/music/MusicDatabase.cpp b/xbmc/music/MusicDatabase.cpp
index 8829b73..203d609 100644 (file)
--- a/xbmc/music/MusicDatabase.cpp
+++ b/xbmc/music/MusicDatabase.cpp
@@ -5656,7 +5656,7 @@ bool CMusicDatabase::GetFilter(CDbUrl &musicUrl, Filter &filter, SortDescription
     if (xsp.GetType()  == type ||
        (xsp.GetGroup() == type && !xsp.IsGroupMixed()))
     {
-      std::set<CStdString> playlists;
+      std::set<std::string> playlists;
       filter.AppendWhere(xsp.GetWhereClause(*this, playlists));
 
       if (xsp.GetLimit() > 0)
@@ -5679,7 +5679,7 @@ bool CMusicDatabase::GetFilter(CDbUrl &musicUrl, Filter &filter, SortDescription
     // check if the filter playlist matches the item type
     if (xspFilter.GetType() == type)
     {
-      std::set<CStdString> playlists;
+      std::set<std::string> playlists;
       filter.AppendWhere(xspFilter.GetWhereClause(*this, playlists));
     }
     // remove the filter if it doesn't match the item type

diff --git a/xbmc/playlists/PlayList.cpp b/xbmc/playlists/PlayList.cpp
index 678253e..a7c3d0b 100644 (file)
--- a/xbmc/playlists/PlayList.cpp
+++ b/xbmc/playlists/PlayList.cpp
@@ -294,12 +294,12 @@ void CPlayList::UnShuffle()
   m_bShuffled = false;
 }
 
-const CStdString& CPlayList::GetName() const
+const std::string& CPlayList::GetName() const
 {
   return m_strPlayListName;
 }
 
-void CPlayList::Remove(const CStdString& strFileName)
+void CPlayList::Remove(const std::string& strFileName)
 {
   int iOrder = -1;
   int position = 0;
@@ -350,7 +350,7 @@ void CPlayList::Remove(int position)
 
 int CPlayList::RemoveDVDItems()
 {
-  std::vector <CStdString> vecFilenames;
+  std::vector <std::string> vecFilenames;
 
   // Collect playlist items from DVD share
   ivecItems it;
@@ -369,11 +369,11 @@ int CPlayList::RemoveDVDItems()
   int nFileCount = vecFilenames.size();
   if ( nFileCount )
   {
-    std::vector <CStdString>::iterator it;
+    std::vector <std::string>::iterator it;
     it = vecFilenames.begin();
     while (it != vecFilenames.end() )
     {
-      CStdString& strFilename = *it;
+      std::string& strFilename = *it;
       Remove( strFilename );
       it++;
     }
@@ -423,7 +423,7 @@ void CPlayList::SetUnPlayable(int iItem)
 }
 
 
-bool CPlayList::Load(const CStdString& strFileName)
+bool CPlayList::Load(const std::string& strFileName)
 {
   Clear();
   m_strBasePath = URIUtils::GetDirectory(strFileName);
@@ -449,7 +449,7 @@ bool CPlayList::LoadData(std::istream &stream)
   return LoadData(ostr.str());
 }
 
-bool CPlayList::LoadData(const CStdString& strData)
+bool CPlayList::LoadData(const std::string& strData)
 {
   return false;
 }
@@ -492,7 +492,7 @@ void CPlayList::UpdateItem(const CFileItem *item)
     CFileItemPtr playlistItem = *it;
     if (playlistItem->IsSamePath(item))
     {
-      CStdString temp = playlistItem->GetPath(); // save path, it may have been altered
+      std::string temp = playlistItem->GetPath(); // save path, it may have been altered
       *playlistItem = *item;
       playlistItem->SetPath(temp);
       break;
@@ -500,7 +500,7 @@ void CPlayList::UpdateItem(const CFileItem *item)
   }
 }
 
-const CStdString CPlayList::ResolveURL(const CFileItemPtr &item ) const
+const std::string& CPlayList::ResolveURL(const CFileItemPtr &item ) const
 {
   if (item->IsMusicDb() && item->HasMusicInfoTag())
     return item->GetMusicInfoTag()->GetURL();

diff --git a/xbmc/playlists/PlayList.h b/xbmc/playlists/PlayList.h
index 1355252..09aabfe 100644 (file)
--- a/xbmc/playlists/PlayList.h
+++ b/xbmc/playlists/PlayList.h
@@ -21,6 +21,7 @@
 
 #include "FileItem.h"
 #include <boost/shared_ptr.hpp>
+#include <string>
 
 namespace PLAYLIST
 {
@@ -29,10 +30,10 @@ class CPlayList
 public:
   CPlayList(int id = -1);
   virtual ~CPlayList(void) {};
-  virtual bool Load(const CStdString& strFileName);
+  virtual bool Load(const std::string& strFileName);
   virtual bool LoadData(std::istream &stream);
-  virtual bool LoadData(const CStdString& strData);
-  virtual void Save(const CStdString& strFileName) const {};
+  virtual bool LoadData(const std::string& strData);
+  virtual void Save(const std::string& strFileName) const {};
 
   void Add(CPlayList& playlist);
   void Add(const CFileItemPtr &pItem);
@@ -44,8 +45,8 @@ public:
   void Insert(const CFileItemPtr& item, int iPosition = -1);
 
   int FindOrder(int iOrder) const;
-  const CStdString& GetName() const;
-  void Remove(const CStdString& strFileName);
+  const std::string& GetName() const;
+  void Remove(const std::string& strFileName);
   void Remove(int position);
   bool Swap(int position1, int position2);
   bool Expand(int position); // expands any playlist at position into this playlist
@@ -68,12 +69,12 @@ public:
 
   void UpdateItem(const CFileItem *item);
 
-  const CStdString ResolveURL(const CFileItemPtr &item) const;
+  const std::string& ResolveURL(const CFileItemPtr &item) const;
 
 protected:
   int m_id;
-  CStdString m_strPlayListName;
-  CStdString m_strBasePath;
+  std::string m_strPlayListName;
+  std::string m_strBasePath;
   int m_iPlayableItems;
   bool m_bShuffled;
   bool m_bWasPlayed;

diff --git a/xbmc/playlists/PlayListB4S.cpp b/xbmc/playlists/PlayListB4S.cpp
index e1c6db7..aaa91d7 100644 (file)
--- a/xbmc/playlists/PlayListB4S.cpp
+++ b/xbmc/playlists/PlayListB4S.cpp
@@ -79,7 +79,7 @@ bool CPlayListB4S::LoadData(istream& stream)
   if (!pEntryElement) return false;
   while (pEntryElement)
   {
-    CStdString strFileName = XMLUtils::GetAttribute(pEntryElement, "Playstring");
+    std::string strFileName = XMLUtils::GetAttribute(pEntryElement, "Playstring");
     size_t iColon = strFileName.find(":");
     if (iColon != std::string::npos)
     {
@@ -97,7 +97,7 @@ bool CPlayListB4S::LoadData(istream& stream)
       }
       if (pNodeInfo)
       {
-        CStdString strInfo = pNodeInfo->FirstChild()->Value();
+        std::string strInfo = pNodeInfo->FirstChild()->Value();
         strFileName = URIUtils::SubstitutePath(strFileName);
         CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
         CFileItemPtr newItem(new CFileItem(strInfo));
@@ -111,10 +111,10 @@ bool CPlayListB4S::LoadData(istream& stream)
   return true;
 }
 
-void CPlayListB4S::Save(const CStdString& strFileName) const
+void CPlayListB4S::Save(const std::string& strFileName) const
 {
   if (!m_vecItems.size()) return ;
-  CStdString strPlaylist = strFileName;
+  std::string strPlaylist = strFileName;
   strPlaylist = CUtil::MakeLegalPath(strPlaylist);
   CFile file;
   if (!file.OpenForWrite(strPlaylist, true))
@@ -122,7 +122,7 @@ void CPlayListB4S::Save(const CStdString& strFileName) const
     CLog::Log(LOGERROR, "Could not save B4S playlist: [%s]", strPlaylist.c_str());
     return ;
   }
-  CStdString write;
+  std::string write;
   write += StringUtils::Format("<?xml version=%c1.0%c encoding='UTF-8' standalone=%cyes%c?>\n", 34, 34, 34, 34);
   write += StringUtils::Format("<WinampXML>\n");
   write += StringUtils::Format("  <playlist num_entries=%c%i%c label=%c%s%c>\n", 34, m_vecItems.size(), 34, 34, m_strPlayListName.c_str(), 34);

diff --git a/xbmc/playlists/PlayListB4S.h b/xbmc/playlists/PlayListB4S.h
index f736190..d24b208 100644 (file)
--- a/xbmc/playlists/PlayListB4S.h
+++ b/xbmc/playlists/PlayListB4S.h
@@ -30,6 +30,6 @@ public:
   CPlayListB4S(void);
   virtual ~CPlayListB4S(void);
   virtual bool LoadData(std::istream& stream);
-  virtual void Save(const CStdString& strFileName) const;
+  virtual void Save(const std::string& strFileName) const;
 };
 }

diff --git a/xbmc/playlists/PlayListFactory.cpp b/xbmc/playlists/PlayListFactory.cpp
index c92a754..9e9e83e 100644 (file)
--- a/xbmc/playlists/PlayListFactory.cpp
+++ b/xbmc/playlists/PlayListFactory.cpp
@@ -30,7 +30,7 @@
 
 using namespace PLAYLIST;
 
-CPlayList* CPlayListFactory::Create(const CStdString& filename)
+CPlayList* CPlayListFactory::Create(const std::string& filename)
 {
   CFileItem item(filename,false);
   return Create(item);
@@ -44,7 +44,7 @@ CPlayList* CPlayListFactory::Create(const CFileItem& item)
     if (item.GetMimeType().empty())
       const_cast<CFileItem&>(item).FillInMimeType();
 
-    CStdString strMimeType = item.GetMimeType();
+    std::string strMimeType = item.GetMimeType();
     StringUtils::ToLower(strMimeType);
 
     if (strMimeType == "video/x-ms-asf"
@@ -72,7 +72,7 @@ CPlayList* CPlayListFactory::Create(const CFileItem& item)
       return new CPlayListWPL();
   }
 
-  CStdString extension = URIUtils::GetExtension(item.GetPath());
+  std::string extension = URIUtils::GetExtension(item.GetPath());
   StringUtils::ToLower(extension);
 
   if (extension == ".m3u" || extension == ".strm")
@@ -105,7 +105,7 @@ CPlayList* CPlayListFactory::Create(const CFileItem& item)
 
 bool CPlayListFactory::IsPlaylist(const CFileItem& item)
 {
-  CStdString strMimeType = item.GetMimeType();
+  std::string strMimeType = item.GetMimeType();
   StringUtils::ToLower(strMimeType);
 
 /* These are abit uncertain 
@@ -138,7 +138,7 @@ bool CPlayListFactory::IsPlaylist(const CURL& url)
                                 ".m3u|.b4s|.pls|.strm|.wpl|.asx|.ram|.url|.pxml");
 }
 
-bool CPlayListFactory::IsPlaylist(const CStdString& filename)
+bool CPlayListFactory::IsPlaylist(const std::string& filename)
 {
   return URIUtils::HasExtension(filename,
                      ".m3u|.b4s|.pls|.strm|.wpl|.asx|.ram|.url|.pxml");

diff --git a/xbmc/playlists/PlayListFactory.h b/xbmc/playlists/PlayListFactory.h
index 7b9a3db..0bd57f6 100644 (file)
--- a/xbmc/playlists/PlayListFactory.h
+++ b/xbmc/playlists/PlayListFactory.h
@@ -19,7 +19,7 @@
  *
  */
 
-#include "utils/StdString.h"
+#include <string>
 
 class CFileItem;
 class CURL;
@@ -31,10 +31,10 @@ namespace PLAYLIST
   class CPlayListFactory
   {
   public:
-    static CPlayList* Create(const CStdString& filename);
+    static CPlayList* Create(const std::string& filename);
     static CPlayList* Create(const CFileItem& item);
     static bool IsPlaylist(const CURL& url);
-    static bool IsPlaylist(const CStdString& filename);
+    static bool IsPlaylist(const std::string& filename);
     static bool IsPlaylist(const CFileItem& item);
   };
 }

diff --git a/xbmc/playlists/PlayListM3U.cpp b/xbmc/playlists/PlayListM3U.cpp
index 69b2ff7..ae198b8 100644 (file)
--- a/xbmc/playlists/PlayListM3U.cpp
+++ b/xbmc/playlists/PlayListM3U.cpp
@@ -67,11 +67,11 @@ CPlayListM3U::~CPlayListM3U(void)
 {}
 
 
-bool CPlayListM3U::Load(const CStdString& strFileName)
+bool CPlayListM3U::Load(const std::string& strFileName)
 {
   char szLine[4096];
-  CStdString strLine;
-  CStdString strInfo = "";
+  std::string strLine;
+  std::string strInfo;
   long lDuration = 0;
 
   Clear();
@@ -102,7 +102,7 @@ bool CPlayListM3U::Load(const CStdString& strFileName)
       {
         // Read the info and duration
         iColon++;
-        CStdString strLength = strLine.substr(iColon, iComma - iColon);
+        std::string strLength = strLine.substr(iColon, iComma - iColon);
         lDuration = atoi(strLength.c_str());
         iComma++;
         strInfo = strLine.substr(iComma);
@@ -113,13 +113,14 @@ bool CPlayListM3U::Load(const CStdString& strFileName)
              !StringUtils::StartsWith(strLine, M3U_ARTIST_MARKER) &&
              !StringUtils::StartsWith(strLine, M3U_ALBUM_MARKER))
     {
-      CStdString strFileName = strLine;
+      std::string strFileName = strLine;
 
       if (strFileName.size() > 0 && strFileName[0] == '#')
         continue; // assume a comment or something else we don't support
 
       // Skip self - do not load playlist recursively
-      if (URIUtils::GetFileName(strFileName).Equals(m_strPlayListName))
+      // We compare case-less in case user has input incorrect case of the current playlist
+      if (StringUtils::EqualsNoCase(URIUtils::GetFileName(strFileName), m_strPlayListName))
         continue;
 
       if (strFileName.length() > 0)
@@ -155,27 +156,27 @@ bool CPlayListM3U::Load(const CStdString& strFileName)
   return true;
 }
 
-void CPlayListM3U::Save(const CStdString& strFileName) const
+void CPlayListM3U::Save(const std::string& strFileName) const
 {
   if (!m_vecItems.size())
     return;
-  CStdString strPlaylist = CUtil::MakeLegalPath(strFileName);
+  std::string strPlaylist = CUtil::MakeLegalPath(strFileName);
   CFile file;
   if (!file.OpenForWrite(strPlaylist,true))
   {
     CLog::Log(LOGERROR, "Could not save M3U playlist: [%s]", strPlaylist.c_str());
     return;
   }
-  CStdString strLine = StringUtils::Format("%s\n",M3U_START_MARKER);
+  std::string strLine = StringUtils::Format("%s\n",M3U_START_MARKER);
   file.Write(strLine.c_str(),strLine.size());
   for (int i = 0; i < (int)m_vecItems.size(); ++i)
   {
     CFileItemPtr item = m_vecItems[i];
-    CStdString strDescription=item->GetLabel();
+    std::string strDescription=item->GetLabel();
     g_charsetConverter.utf8ToStringCharset(strDescription);
     strLine = StringUtils::Format( "%s:%i,%s\n", M3U_INFO_MARKER, item->GetMusicInfoTag()->GetDuration() / 1000, strDescription.c_str() );
     file.Write(strLine.c_str(),strLine.size());
-    CStdString strFileName = ResolveURL(item);
+    std::string strFileName = ResolveURL(item);
     g_charsetConverter.utf8ToStringCharset(strFileName);
     strLine = StringUtils::Format("%s\n",strFileName.c_str());
     file.Write(strLine.c_str(),strLine.size());
@@ -183,13 +184,13 @@ void CPlayListM3U::Save(const CStdString& strFileName) const
   file.Close();
 }
 
-CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, size_t bandwidth)
+std::string CPlayListM3U::GetBestBandwidthStream(const std::string &strFileName, size_t bandwidth)
 {
   // we may be passed a playlist that does not contain playlists of different
   // bitrates (eg: this playlist is really the HLS video). So, default the
   // return to the filename so it can be played
   char szLine[4096];
-  CStdString strLine;
+  std::string strLine;
   size_t maxBandwidth = 0;
 
   // open the file, and if it fails, return
@@ -210,7 +211,7 @@ CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, s
   CURL basePlaylistUrl(URIUtils::GetParentPath(strFileName));
   basePlaylistUrl.SetOptions("");
   basePlaylistUrl.SetProtocolOptions("");
-  CStdString basePart = basePlaylistUrl.Get();
+  std::string basePart = basePlaylistUrl.Get();
 
   // convert bandwidth specified in kbps to bps used by the m3u8
   bandwidth *= 1000;
@@ -227,8 +228,8 @@ CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, s
     else if (StringUtils::StartsWith(strLine, M3U_STREAM_MARKER))
     {
       // parse the line so we can pull out the bandwidth
-      std::map< CStdString, CStdString > params = ParseStreamLine(strLine);
-      std::map< CStdString, CStdString >::iterator it = params.find(M3U_BANDWIDTH_MARKER);
+      std::map< std::string, std::string > params = ParseStreamLine(strLine);
+      std::map< std::string, std::string >::iterator it = params.find(M3U_BANDWIDTH_MARKER);
 
       if (it != params.end())
       {
@@ -264,16 +265,16 @@ CStdString CPlayListM3U::GetBestBandwidthStream(const CStdString &strFileName, s
   return subStreamUrl.Get();
 }
 
-std::map< CStdString, CStdString > CPlayListM3U::ParseStreamLine(const CStdString &streamLine)
+std::map< std::string, std::string > CPlayListM3U::ParseStreamLine(const std::string &streamLine)
 {
-  std::map< CStdString, CStdString > params;
+  std::map< std::string, std::string > params;
 
   // ensure the line has something beyond the stream marker and ':'
-  if (strlen(streamLine) < strlen(M3U_STREAM_MARKER) + 2)
+  if (streamLine.size() < strlen(M3U_STREAM_MARKER) + 2)
     return params;
 
   // get the actual params following the :
-  CStdString strParams(streamLine.substr(strlen(M3U_STREAM_MARKER) + 1));
+  std::string strParams(streamLine.substr(strlen(M3U_STREAM_MARKER) + 1));
 
   // separate the parameters
   std::vector<std::string> vecParams = StringUtils::Split(strParams, ",");

diff --git a/xbmc/playlists/PlayListM3U.h b/xbmc/playlists/PlayListM3U.h
index f1edcb3..4ecfb0b 100644 (file)
--- a/xbmc/playlists/PlayListM3U.h
+++ b/xbmc/playlists/PlayListM3U.h
@@ -28,13 +28,13 @@ class CPlayListM3U :
 public:
   CPlayListM3U(void);
   virtual ~CPlayListM3U(void);
-  virtual bool Load(const CStdString& strFileName);
-  virtual void Save(const CStdString& strFileName) const;
+  virtual bool Load(const std::string& strFileName);
+  virtual void Save(const std::string& strFileName) const;
 
-  static CStdString GetBestBandwidthStream(const CStdString &strFileName, size_t bandwidth);
+  static std::string GetBestBandwidthStream(const std::string &strFileName, size_t bandwidth);
 
 protected:
 
-  static std::map< CStdString, CStdString > ParseStreamLine(const CStdString &streamLine);
+  static std::map<std::string,std::string> ParseStreamLine(const std::string &streamLine);
 };
 }

diff --git a/xbmc/playlists/PlayListPLS.cpp b/xbmc/playlists/PlayListPLS.cpp
index 3c1d624..1058908 100644 (file)
--- a/xbmc/playlists/PlayListPLS.cpp
+++ b/xbmc/playlists/PlayListPLS.cpp
@@ -35,7 +35,7 @@ using namespace std;
 using namespace XFILE;
 using namespace PLAYLIST;
 
-#define START_PLAYLIST_MARKER "[playlist]"
+#define START_PLAYLIST_MARKER "[playlist]" // may be case-insentive (equivalent to .ini file on win32)
 #define PLAYLIST_NAME     "PlaylistName"
 
 /*----------------------------------------------------------------------
@@ -56,10 +56,10 @@ CPlayListPLS::CPlayListPLS(void)
 CPlayListPLS::~CPlayListPLS(void)
 {}
 
-bool CPlayListPLS::Load(const CStdString &strFile)
+bool CPlayListPLS::Load(const std::string &strFile)
 {
   //read it from the file
-  CStdString strFileName(strFile);
+  std::string strFileName(strFile);
   m_strPlayListName = URIUtils::GetFileName(strFileName);
 
   Clear();
@@ -88,7 +88,7 @@ bool CPlayListPLS::Load(const CStdString &strFile)
   }
 
   char szLine[4096];
-  CStdString strLine;
+  std::string strLine;
 
   // run through looking for the [playlist] marker.
   // if we find another http stream, then load it.
@@ -101,7 +101,7 @@ bool CPlayListPLS::Load(const CStdString &strFile)
     }
     strLine = szLine;
     StringUtils::Trim(strLine);
-    if(strLine.Equals(START_PLAYLIST_MARKER))
+    if(StringUtils::EqualsNoCase(strLine, START_PLAYLIST_MARKER))
       break;
 
     // if there is something else before playlist marker, this isn't a pls file
@@ -117,9 +117,9 @@ bool CPlayListPLS::Load(const CStdString &strFile)
     size_t iPosEqual = strLine.find("=");
     if (iPosEqual != std::string::npos)
     {
-      CStdString strLeft = strLine.substr(0, iPosEqual);
+      std::string strLeft = strLine.substr(0, iPosEqual);
       iPosEqual++;
-      CStdString strValue = strLine.substr(iPosEqual);
+      std::string strValue = strLine.substr(iPosEqual);
       StringUtils::ToLower(strLeft);
       StringUtils::TrimLeft(strLeft);
 
@@ -137,7 +137,8 @@ bool CPlayListPLS::Load(const CStdString &strFile)
         }
 
         // Skip self - do not load playlist recursively
-        if (URIUtils::GetFileName(strValue).Equals(URIUtils::GetFileName(strFileName)))
+        if (StringUtils::EqualsNoCase(URIUtils::GetFileName(strValue),
+                                      URIUtils::GetFileName(strFileName)))
           continue;
 
         if (m_vecItems[idx - 1]->GetLabel().empty())
@@ -204,28 +205,28 @@ bool CPlayListPLS::Load(const CStdString &strFile)
   return true;
 }
 
-void CPlayListPLS::Save(const CStdString& strFileName) const
+void CPlayListPLS::Save(const std::string& strFileName) const
 {
   if (!m_vecItems.size()) return ;
-  CStdString strPlaylist = CUtil::MakeLegalPath(strFileName);
+  std::string strPlaylist = CUtil::MakeLegalPath(strFileName);
   CFile file;
   if (!file.OpenForWrite(strPlaylist, true))
   {
     CLog::Log(LOGERROR, "Could not save PLS playlist: [%s]", strPlaylist.c_str());
     return;
   }
-  CStdString write;
+  std::string write;
   write += StringUtils::Format("%s\n", START_PLAYLIST_MARKER);
-  CStdString strPlayListName=m_strPlayListName;
+  std::string strPlayListName=m_strPlayListName;
   g_charsetConverter.utf8ToStringCharset(strPlayListName);
   write += StringUtils::Format("PlaylistName=%s\n", strPlayListName.c_str() );
 
   for (int i = 0; i < (int)m_vecItems.size(); ++i)
   {
     CFileItemPtr item = m_vecItems[i];
-    CStdString strFileName=item->GetPath();
+    std::string strFileName=item->GetPath();
     g_charsetConverter.utf8ToStringCharset(strFileName);
-    CStdString strDescription=item->GetLabel();
+    std::string strDescription=item->GetLabel();
     g_charsetConverter.utf8ToStringCharset(strDescription);
     write += StringUtils::Format("File%i=%s\n", i + 1, strFileName.c_str() );
     write += StringUtils::Format("Title%i=%s\n", i + 1, strDescription.c_str() );
@@ -304,7 +305,7 @@ bool CPlayListASX::LoadData(istream& stream)
     // lowercase every element
     TiXmlNode *pNode = pRootElement;
     TiXmlNode *pChild = NULL;
-    CStdString value;
+    std::string value;
     value = pNode->Value();
     StringUtils::ToLower(value);
     pNode->SetValue(value);
@@ -337,7 +338,7 @@ bool CPlayListASX::LoadData(istream& stream)
       pChild = pNode;
       pNode = pNode->Parent();
     }
-    CStdString roottitle = "";
+    std::string roottitle;
     TiXmlElement *pElement = pRootElement->FirstChildElement();
     while (pElement)
     {
@@ -348,7 +349,7 @@ bool CPlayListASX::LoadData(istream& stream)
       }
       else if (value == "entry")
       {
-        CStdString title(roottitle);
+        std::string title(roottitle);
 
         TiXmlElement *pRef = pElement->FirstChildElement("ref");
         TiXmlElement *pTitle = pElement->FirstChildElement("title");
@@ -396,7 +397,7 @@ bool CPlayListRAM::LoadData(istream& stream)
 {
   CLog::Log(LOGINFO, "Parsing RAM");
 
-  CStdString strMMS;
+  std::string strMMS;
   while( stream.peek() != '\n' && stream.peek() != '\r' )
     strMMS += stream.get();
 

diff --git a/xbmc/playlists/PlayListPLS.h b/xbmc/playlists/PlayListPLS.h
index d6dc59a..49769c4 100644 (file)
--- a/xbmc/playlists/PlayListPLS.h
+++ b/xbmc/playlists/PlayListPLS.h
@@ -28,8 +28,8 @@ class CPlayListPLS :
 public:
   CPlayListPLS(void);
   virtual ~CPlayListPLS(void);
-  virtual bool Load(const CStdString& strFileName);
-  virtual void Save(const CStdString& strFileName) const;
+  virtual bool Load(const std::string& strFileName);
+  virtual void Save(const std::string& strFileName) const;
   virtual bool Resize(std::vector<int>::size_type newSize);
 };
 

diff --git a/xbmc/playlists/PlayListURL.cpp b/xbmc/playlists/PlayListURL.cpp
index ade2ed2..51793b5 100644 (file)
--- a/xbmc/playlists/PlayListURL.cpp
+++ b/xbmc/playlists/PlayListURL.cpp
@@ -38,10 +38,10 @@ CPlayListURL::CPlayListURL(void)
 CPlayListURL::~CPlayListURL(void)
 {}
 
-bool CPlayListURL::Load(const CStdString& strFileName)
+bool CPlayListURL::Load(const std::string& strFileName)
 {
   char szLine[4096];
-  CStdString strLine;
+  std::string strLine;
 
   Clear();
 

diff --git a/xbmc/playlists/PlayListURL.h b/xbmc/playlists/PlayListURL.h
index 23c6a79..813e8c5 100644 (file)
--- a/xbmc/playlists/PlayListURL.h
+++ b/xbmc/playlists/PlayListURL.h
@@ -28,6 +28,6 @@ class CPlayListURL :
 public:
   CPlayListURL(void);
   virtual ~CPlayListURL(void);
-  virtual bool Load(const CStdString& strFileName);
+  virtual bool Load(const std::string& strFileName);
 };
 }

diff --git a/xbmc/playlists/PlayListWPL.cpp b/xbmc/playlists/PlayListWPL.cpp
index 851ac8f..4426048 100644 (file)
--- a/xbmc/playlists/PlayListWPL.cpp
+++ b/xbmc/playlists/PlayListWPL.cpp
@@ -90,12 +90,12 @@ bool CPlayListWPL::LoadData(istream& stream)
   if (!pMediaElement) return false;
   while (pMediaElement)
   {
-    CStdString strFileName = XMLUtils::GetAttribute(pMediaElement, "src");
+    std::string strFileName = XMLUtils::GetAttribute(pMediaElement, "src");
     if (!strFileName.empty())
     {
-      strFileName = URIUtils::SubstitutePath(strFileName);
+      std::string strFileName = URIUtils::SubstitutePath(strFileName);
       CUtil::GetQualifiedFilename(m_strBasePath, strFileName);
-      CStdString strDescription = URIUtils::GetFileName(strFileName);
+      std::string strDescription = URIUtils::GetFileName(strFileName);
       CFileItemPtr newItem(new CFileItem(strDescription));
       newItem->SetPath(strFileName);
       Add(newItem);
@@ -105,17 +105,17 @@ bool CPlayListWPL::LoadData(istream& stream)
   return true;
 }
 
-void CPlayListWPL::Save(const CStdString& strFileName) const
+void CPlayListWPL::Save(const std::string& strFileName) const
 {
   if (!m_vecItems.size()) return ;
-  CStdString strPlaylist = CUtil::MakeLegalPath(strFileName);
+  std::string strPlaylist = CUtil::MakeLegalPath(strFileName);
   CFile file;
   if (!file.OpenForWrite(strPlaylist, true))
   {
     CLog::Log(LOGERROR, "Could not save WPL playlist: [%s]", strPlaylist.c_str());
     return ;
   }
-  CStdString write;
+  std::string write;
   write += StringUtils::Format("<?wpl version=%c1.0%c>\n", 34, 34);
   write += StringUtils::Format("<smil>\n");
   write += StringUtils::Format("    <head>\n");

diff --git a/xbmc/playlists/PlayListWPL.h b/xbmc/playlists/PlayListWPL.h
index 4c130af..bf5ec89 100644 (file)
--- a/xbmc/playlists/PlayListWPL.h
+++ b/xbmc/playlists/PlayListWPL.h
@@ -30,6 +30,6 @@ public:
   CPlayListWPL(void);
   virtual ~CPlayListWPL(void);
   virtual bool LoadData(std::istream& stream);
-  virtual void Save(const CStdString& strFileName) const;
+  virtual void Save(const std::string& strFileName) const;
 };
 }

diff --git a/xbmc/playlists/PlayListXML.cpp b/xbmc/playlists/PlayListXML.cpp
index 3ca9623..66bea08 100644 (file)
--- a/xbmc/playlists/PlayListXML.cpp
+++ b/xbmc/playlists/PlayListXML.cpp
@@ -70,16 +70,16 @@ CPlayListXML::~CPlayListXML(void)
 {}
 
 
-static inline CStdString GetString( const TiXmlElement* pRootElement, const char *tagName )
+static inline std::string GetString( const TiXmlElement* pRootElement, const char *tagName )
 {
-  CStdString strValue;
+  std::string strValue;
   if ( XMLUtils::GetString(pRootElement, tagName, strValue) )
     return strValue;
 
   return "";
 }
 
-bool CPlayListXML::Load( const CStdString& strFileName )
+bool CPlayListXML::Load( const std::string& strFileName )
 {
   CXBMCTinyXML xmlDoc;
 
@@ -109,12 +109,12 @@ bool CPlayListXML::Load( const CStdString& strFileName )
   while ( pSet )
   {
     // Get parameters
-    CStdString url = GetString( pSet, "url" );
-    CStdString name = GetString( pSet, "name" );
-    CStdString category = GetString( pSet, "category" );
-    CStdString lang = GetString( pSet, "lang" );
-    CStdString channel = GetString( pSet, "channel" );
-    CStdString lockpass = GetString( pSet, "lockpassword" );
+    std::string url = GetString( pSet, "url" );
+    std::string name = GetString( pSet, "name" );
+    std::string category = GetString( pSet, "category" );
+    std::string lang = GetString( pSet, "lang" );
+    std::string channel = GetString( pSet, "channel" );
+    std::string lockpass = GetString( pSet, "lockpassword" );
 
     // If url is empty, it doesn't make any sense
     if ( !url.empty() )
@@ -127,7 +127,7 @@ bool CPlayListXML::Load( const CStdString& strFileName )
        if ( !lang.empty() )
          name += " [" + lang + "]";
 
-       CStdString info = name;
+       std::string info = name;
        CFileItemPtr newItem( new CFileItem(info) );
        newItem->SetPath(url);
 
@@ -165,17 +165,17 @@ bool CPlayListXML::Load( const CStdString& strFileName )
 }
 
 
-void CPlayListXML::Save(const CStdString& strFileName) const
+void CPlayListXML::Save(const std::string& strFileName) const
 {
   if (!m_vecItems.size()) return ;
-  CStdString strPlaylist = CUtil::MakeLegalPath(strFileName);
+  std::string strPlaylist = CUtil::MakeLegalPath(strFileName);
   CFile file;
   if (!file.OpenForWrite(strPlaylist, true))
   {
     CLog::Log(LOGERROR, "Could not save WPL playlist: [%s]", strPlaylist.c_str());
     return ;
   }
-  CStdString write;
+  std::string write;
   write += StringUtils::Format("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
   write += StringUtils::Format("<streams>\n");
   for (int i = 0; i < (int)m_vecItems.size(); ++i)

diff --git a/xbmc/playlists/PlayListXML.h b/xbmc/playlists/PlayListXML.h
index 60a0541..8917f37 100644 (file)
--- a/xbmc/playlists/PlayListXML.h
+++ b/xbmc/playlists/PlayListXML.h
@@ -28,7 +28,7 @@ class CPlayListXML :
 public:
   CPlayListXML(void);
   virtual ~CPlayListXML(void);
-  virtual bool Load(const CStdString& strFileName);
-  virtual void Save(const CStdString& strFileName) const;
+  virtual bool Load(const std::string& strFileName);
+  virtual void Save(const std::string& strFileName) const;
 };
 }

diff --git a/xbmc/playlists/SmartPlayList.cpp b/xbmc/playlists/SmartPlayList.cpp
index cbe5c4d..95ba99c 100644 (file)
--- a/xbmc/playlists/SmartPlayList.cpp
+++ b/xbmc/playlists/SmartPlayList.cpp
@@ -168,7 +168,7 @@ SortBy CSmartPlaylistRule::TranslateOrder(const char *order)
   return SortByNone;
 }
 
-CStdString CSmartPlaylistRule::TranslateOrder(SortBy order)
+std::string CSmartPlaylistRule::TranslateOrder(SortBy order)
 {
   for (unsigned int i = 0; i < NUM_FIELDS; i++)
     if (order == fields[i].sort) return fields[i].string;
@@ -186,7 +186,7 @@ Field CSmartPlaylistRule::TranslateGroup(const char *group)
   return FieldUnknown;
 }
 
-CStdString CSmartPlaylistRule::TranslateGroup(Field group)
+std::string CSmartPlaylistRule::TranslateGroup(Field group)
 {
   for (unsigned int i = 0; i < NUM_GROUPS; i++)
   {
@@ -197,7 +197,7 @@ CStdString CSmartPlaylistRule::TranslateGroup(Field group)
   return "";
 }
 
-CStdString CSmartPlaylistRule::GetLocalizedField(int field)
+std::string CSmartPlaylistRule::GetLocalizedField(int field)
 {
   for (unsigned int i = 0; i < NUM_FIELDS; i++)
     if (field == fields[i].field) return g_localizeStrings.Get(fields[i].localizedString);
@@ -261,7 +261,7 @@ bool CSmartPlaylistRule::ValidateRating(const std::string &input, void *data)
          rating >= 0.0 && rating <= 10.0;
 }
 
-vector<Field> CSmartPlaylistRule::GetFields(const CStdString &type)
+vector<Field> CSmartPlaylistRule::GetFields(const std::string &type)
 {
   vector<Field> fields;
   bool isVideo = false;
@@ -423,7 +423,7 @@ vector<Field> CSmartPlaylistRule::GetFields(const CStdString &type)
   return fields;
 }
 
-std::vector<SortBy> CSmartPlaylistRule::GetOrders(const CStdString &type)
+std::vector<SortBy> CSmartPlaylistRule::GetOrders(const std::string &type)
 {
   vector<SortBy> orders;
   orders.push_back(SortByNone);
@@ -533,7 +533,7 @@ std::vector<SortBy> CSmartPlaylistRule::GetOrders(const CStdString &type)
   return orders;
 }
 
-std::vector<Field> CSmartPlaylistRule::GetGroups(const CStdString &type)
+std::vector<Field> CSmartPlaylistRule::GetGroups(const std::string &type)
 {
   vector<Field> groups;
   groups.push_back(FieldUnknown);
@@ -578,7 +578,7 @@ std::vector<Field> CSmartPlaylistRule::GetGroups(const CStdString &type)
   return groups;
 }
 
-CStdString CSmartPlaylistRule::GetLocalizedGroup(Field group)
+std::string CSmartPlaylistRule::GetLocalizedGroup(Field group)
 {
   for (unsigned int i = 0; i < NUM_GROUPS; i++)
   {
@@ -600,14 +600,14 @@ bool CSmartPlaylistRule::CanGroupMix(Field group)
   return false;
 }
 
-CStdString CSmartPlaylistRule::GetLocalizedRule() const
+std::string CSmartPlaylistRule::GetLocalizedRule() const
 {
   return StringUtils::Format("%s %s %s", GetLocalizedField(m_field).c_str(), GetLocalizedOperator(m_operator).c_str(), GetParameter().c_str());
 }
 
-CStdString CSmartPlaylistRule::GetVideoResolutionQuery(const CStdString &parameter) const
+std::string CSmartPlaylistRule::GetVideoResolutionQuery(const std::string &parameter) const
 {
-  CStdString retVal(" IN (SELECT DISTINCT idFile FROM streamdetails WHERE iVideoWidth ");
+  std::string retVal(" IN (SELECT DISTINCT idFile FROM streamdetails WHERE iVideoWidth ");
   int iRes = (int)strtol(parameter.c_str(), NULL, 10);
 
   int min, max;
@@ -684,7 +684,7 @@ std::string CSmartPlaylistRule::FormatParameter(const std::string &operatorStrin
   // special-casing
   if (m_field == FieldTime)
   { // translate time to seconds
-    CStdString seconds = StringUtils::Format("%i", StringUtils::TimeStringToSeconds(param));
+    std::string seconds = StringUtils::Format("%i", StringUtils::TimeStringToSeconds(param));
     return db.PrepareSQL(operatorString.c_str(), seconds.c_str());
   }
   return CDatabaseQueryRule::FormatParameter(operatorString, param, db, strType);
@@ -807,7 +807,7 @@ std::string CSmartPlaylistRule::FormatWhereClause(const std::string &negate, con
       query = negate + " (" + GetField(m_field, strType) +  parameter + ")";
   }
   if (m_field == FieldVideoResolution)
-    query = (CStdString)table + ".idFile" + (CStdString)negate + GetVideoResolutionQuery(param);
+    query = table + ".idFile" + negate + GetVideoResolutionQuery(param);
   else if (m_field == FieldAudioChannels)
     query = negate + " EXISTS (SELECT 1 FROM streamdetails WHERE streamdetails.idFile = " + table + ".idFile AND iAudioChannels " + parameter + ")";
   else if (m_field == FieldVideoCodec)
@@ -842,9 +842,9 @@ std::string CSmartPlaylistRule::GetField(int field, const std::string &type) con
   return "";
 }
 
-CStdString CSmartPlaylistRuleCombination::GetWhereClause(const CDatabase &db, const CStdString& strType, std::set<CStdString> &referencedPlaylists) const
+std::string CSmartPlaylistRuleCombination::GetWhereClause(const CDatabase &db, const std::string& strType, std::set<std::string> &referencedPlaylists) const
 {
-  CStdString rule, currentRule;
+  std::string rule, currentRule;
   
   // translate the combinations into SQL
   for (CDatabaseQueryRuleCombinations::const_iterator it = m_combinations.begin(); it != m_combinations.end(); ++it)
@@ -867,24 +867,24 @@ CStdString CSmartPlaylistRuleCombination::GetWhereClause(const CDatabase &db, co
     if (!rule.empty())
       rule += m_type == CombinationAnd ? " AND " : " OR ";
     rule += "(";
-    CStdString currentRule;
+    std::string currentRule;
     if ((*it)->m_field == FieldPlaylist)
     {
-      CStdString playlistFile = CSmartPlaylistDirectory::GetPlaylistByName((*it)->m_parameter.at(0), strType);
+      std::string playlistFile = CSmartPlaylistDirectory::GetPlaylistByName((*it)->m_parameter.at(0), strType);
       if (!playlistFile.empty() && referencedPlaylists.find(playlistFile) == referencedPlaylists.end())
       {
         referencedPlaylists.insert(playlistFile);
         CSmartPlaylist playlist;
         if (playlist.Load(playlistFile))
         {
-          CStdString playlistQuery;
+          std::string playlistQuery;
           // only playlists of same type will be part of the query
-          if (playlist.GetType().Equals(strType) || (playlist.GetType().Equals("mixed") && (strType == "songs" || strType == "musicvideos")) || playlist.GetType().empty())
+          if (playlist.GetType() == strType || (playlist.GetType() == "mixed" && (strType == "songs" || strType == "musicvideos")) || playlist.GetType().empty())
           {
             playlist.SetType(strType);
             playlistQuery = playlist.GetWhereClause(db, referencedPlaylists);
           }
-          if (playlist.GetType().Equals(strType))
+          if (playlist.GetType() == strType)
           {
             if ((*it)->m_operator == CDatabaseQueryRule::OPERATOR_DOES_NOT_EQUAL)
               currentRule = StringUtils::Format("NOT (%s)", playlistQuery.c_str());
@@ -906,7 +906,7 @@ CStdString CSmartPlaylistRuleCombination::GetWhereClause(const CDatabase &db, co
   return rule;
 }
 
-void CSmartPlaylistRuleCombination::GetVirtualFolders(const CStdString& strType, std::vector<CStdString> &virtualFolders) const
+void CSmartPlaylistRuleCombination::GetVirtualFolders(const std::string& strType, std::vector<std::string> &virtualFolders) const
 {
   for (CDatabaseQueryRuleCombinations::const_iterator it = m_combinations.begin(); it != m_combinations.end(); ++it)
   {
@@ -920,7 +920,7 @@ void CSmartPlaylistRuleCombination::GetVirtualFolders(const CStdString& strType,
     if (((*it)->m_field != FieldVirtualFolder && (*it)->m_field != FieldPlaylist) || (*it)->m_operator != CDatabaseQueryRule::OPERATOR_EQUALS)
       continue;
 
-    CStdString playlistFile = CSmartPlaylistDirectory::GetPlaylistByName((*it)->m_parameter.at(0), strType);
+    std::string playlistFile = CSmartPlaylistDirectory::GetPlaylistByName((*it)->m_parameter.at(0), strType);
     if (playlistFile.empty())
       continue;
 
@@ -1012,7 +1012,7 @@ const TiXmlNode* CSmartPlaylist::readNameFromPath(const CURL &url)
   return root;
 }
 
-const TiXmlNode* CSmartPlaylist::readNameFromXml(const CStdString &xml)
+const TiXmlNode* CSmartPlaylist::readNameFromXml(const std::string &xml)
 {
   if (xml.empty())
   {
@@ -1045,7 +1045,7 @@ bool CSmartPlaylist::Load(const CURL &url)
   return load(readNameFromPath(url));
 }
 
-bool CSmartPlaylist::Load(const CStdString &path)
+bool CSmartPlaylist::Load(const std::string &path)
 {
   const CURL pathToUrl(path);
   return load(readNameFromPath(pathToUrl));
@@ -1100,17 +1100,17 @@ bool CSmartPlaylist::Load(const CVariant &obj)
   return true;
 }
 
-bool CSmartPlaylist::LoadFromXml(const CStdString &xml)
+bool CSmartPlaylist::LoadFromXml(const std::string &xml)
 {
   return load(readNameFromXml(xml));
 }
 
-bool CSmartPlaylist::LoadFromXML(const TiXmlNode *root, const CStdString &encoding)
+bool CSmartPlaylist::LoadFromXML(const TiXmlNode *root, const std::string &encoding)
 {
   if (!root)
     return false;
 
-  CStdString tmp;
+  std::string tmp;
   if (XMLUtils::GetString(root, "match", tmp))
     m_ruleCombination.SetType(StringUtils::EqualsNoCase(tmp, "all") ? CSmartPlaylistRuleCombination::CombinationAnd : CSmartPlaylistRuleCombination::CombinationOr);
 
@@ -1155,7 +1155,7 @@ bool CSmartPlaylist::LoadFromXML(const TiXmlNode *root, const CStdString &encodi
   return true;
 }
 
-bool CSmartPlaylist::LoadFromJson(const CStdString &json)
+bool CSmartPlaylist::LoadFromJson(const std::string &json)
 {
   if (json.empty())
     return false;
@@ -1164,7 +1164,7 @@ bool CSmartPlaylist::LoadFromJson(const CStdString &json)
   return Load(obj);
 }
 
-bool CSmartPlaylist::Save(const CStdString &path) const
+bool CSmartPlaylist::Save(const std::string &path) const
 {
   CXBMCTinyXML doc;
   TiXmlDeclaration decl("1.0", "UTF-8", "yes");
@@ -1251,7 +1251,7 @@ bool CSmartPlaylist::Save(CVariant &obj, bool full /* = true */) const
   return true;
 }
 
-bool CSmartPlaylist::SaveAsJson(CStdString &json, bool full /* = true */) const
+bool CSmartPlaylist::SaveAsJson(std::string &json, bool full /* = true */) const
 {
   CVariant xsp(CVariant::VariantTypeObject);
   if (!Save(xsp, full))
@@ -1273,12 +1273,12 @@ void CSmartPlaylist::Reset()
   m_groupMixed = false;
 }
 
-void CSmartPlaylist::SetName(const CStdString &name)
+void CSmartPlaylist::SetName(const std::string &name)
 {
   m_playlistName = name;
 }
 
-void CSmartPlaylist::SetType(const CStdString &type)
+void CSmartPlaylist::SetType(const std::string &type)
 {
   m_playlistType = type;
 }
@@ -1293,29 +1293,29 @@ bool CSmartPlaylist::IsMusicType() const
   return IsMusicType(m_playlistType);
 }
 
-bool CSmartPlaylist::IsVideoType(const CStdString &type)
+bool CSmartPlaylist::IsVideoType(const std::string &type)
 {
   return type == "movies" || type == "tvshows" || type == "episodes" ||
          type == "musicvideos" || type == "mixed";
 }
 
-bool CSmartPlaylist::IsMusicType(const CStdString &type)
+bool CSmartPlaylist::IsMusicType(const std::string &type)
 {
   return type == "artists" || type == "albums" ||
          type == "songs" || type == "mixed";
 }
 
-CStdString CSmartPlaylist::GetWhereClause(const CDatabase &db, set<CStdString> &referencedPlaylists) const
+std::string CSmartPlaylist::GetWhereClause(const CDatabase &db, set<std::string> &referencedPlaylists) const
 {
   return m_ruleCombination.GetWhereClause(db, GetType(), referencedPlaylists);
 }
 
-void CSmartPlaylist::GetVirtualFolders(std::vector<CStdString> &virtualFolders) const
+void CSmartPlaylist::GetVirtualFolders(std::vector<std::string> &virtualFolders) const
 {
   m_ruleCombination.GetVirtualFolders(GetType(), virtualFolders);
 }
 
-CStdString CSmartPlaylist::GetSaveLocation() const
+std::string CSmartPlaylist::GetSaveLocation() const
 {
   if (m_playlistType == "mixed")
     return "mixed";
@@ -1347,17 +1347,17 @@ bool CSmartPlaylist::IsEmpty(bool ignoreSortAndLimit /* = true */) const
   return empty;
 }
 
-bool CSmartPlaylist::CheckTypeCompatibility(const CStdString &typeLeft, const CStdString &typeRight)
+bool CSmartPlaylist::CheckTypeCompatibility(const std::string &typeLeft, const std::string &typeRight)
 {
-  if (typeLeft.Equals(typeRight))
+  if (typeLeft == typeRight)
     return true;
 
-  if (typeLeft.Equals("mixed") &&
-     (typeRight.Equals("songs") || typeRight.Equals("musicvideos")))
+  if (typeLeft == "mixed" &&
+     (typeRight == "songs" || typeRight == "musicvideos"))
     return true;
 
-  if (typeRight.Equals("mixed") &&
-     (typeLeft.Equals("songs") || typeLeft.Equals("musicvideos")))
+  if (typeRight == "mixed" &&
+     (typeLeft == "songs" || typeLeft == "musicvideos"))
     return true;
 
   return false;

diff --git a/xbmc/playlists/SmartPlayList.h b/xbmc/playlists/SmartPlayList.h
index 28bc971..5d8187a 100644 (file)
--- a/xbmc/playlists/SmartPlayList.h
+++ b/xbmc/playlists/SmartPlayList.h
@@ -20,12 +20,12 @@
  */
 
 #include <set>
+#include <string>
 #include <vector>
 #include <boost/shared_ptr.hpp>
 
 #include "dbwrappers/DatabaseQuery.h"
 #include "utils/SortUtils.h"
-#include "utils/StdString.h"
 #include "utils/XBMCTinyXML.h"
 
 class CURL;
@@ -37,20 +37,20 @@ public:
   CSmartPlaylistRule();
   virtual ~CSmartPlaylistRule() { }
 
-  CStdString                  GetLocalizedRule() const;
+  std::string                 GetLocalizedRule() const;
 
   static SortBy               TranslateOrder(const char *order);
-  static CStdString           TranslateOrder(SortBy order);
+  static std::string          TranslateOrder(SortBy order);
   static Field                TranslateGroup(const char *group);
-  static CStdString           TranslateGroup(Field group);
+  static std::string          TranslateGroup(Field group);
 
-  static CStdString           GetLocalizedField(int field);
-  static CStdString           GetLocalizedGroup(Field group);
+  static std::string          GetLocalizedField(int field);
+  static std::string          GetLocalizedGroup(Field group);
   static bool                 CanGroupMix(Field group);
 
-  static std::vector<Field>   GetFields(const CStdString &type);
-  static std::vector<SortBy>  GetOrders(const CStdString &type);
-  static std::vector<Field>   GetGroups(const CStdString &type);
+  static std::vector<Field>   GetFields(const std::string &type);
+  static std::vector<SortBy>  GetOrders(const std::string &type);
+  static std::vector<Field>   GetGroups(const std::string &type);
   virtual FIELD_TYPE          GetFieldType(int field) const;
   static bool                 IsFieldBrowseable(int field);
 
@@ -75,7 +75,7 @@ protected:
                                               const std::string &strType) const;
 
 private:
-  CStdString GetVideoResolutionQuery(const CStdString &parameter) const;
+  std::string GetVideoResolutionQuery(const std::string &parameter) const;
 };
 
 class CSmartPlaylistRuleCombination : public CDatabaseQueryRuleCombination
@@ -84,8 +84,11 @@ public:
   CSmartPlaylistRuleCombination() { }
   virtual ~CSmartPlaylistRuleCombination() { }
 
-  CStdString GetWhereClause(const CDatabase &db, const CStdString& strType, std::set<CStdString> &referencedPlaylists) const;
-  void GetVirtualFolders(const CStdString& strType, std::vector<CStdString> &virtualFolders) const;
+  std::string GetWhereClause(const CDatabase &db,
+                             const std::string& strType,
+                             std::set<std::string> &referencedPlaylists) const;
+  void GetVirtualFolders(const std::string& strType,
+                         std::vector<std::string> &virtualFolders) const;
 
   void AddRule(const CSmartPlaylistRule &rule);
 };
@@ -97,23 +100,23 @@ public:
   virtual ~CSmartPlaylist() { }
 
   bool Load(const CURL& url);
-  bool Load(const CStdString &path);
+  bool Load(const std::string &path);
   bool Load(const CVariant &obj);
-  bool LoadFromXml(const CStdString &xml);
-  bool LoadFromJson(const CStdString &json);
-  bool Save(const CStdString &path) const;
+  bool LoadFromXml(const std::string &xml);
+  bool LoadFromJson(const std::string &json);
+  bool Save(const std::string &path) const;
   bool Save(CVariant &obj, bool full = true) const;
-  bool SaveAsJson(CStdString &json, bool full = true) const;
+  bool SaveAsJson(std::string &json, bool full = true) const;
 
   bool OpenAndReadName(const CURL &url);
-  bool LoadFromXML(const TiXmlNode *root, const CStdString &encoding = "UTF-8");
+  bool LoadFromXML(const TiXmlNode *root, const std::string &encoding = "UTF-8");
 
   void Reset();
 
-  void SetName(const CStdString &name);
-  void SetType(const CStdString &type); // music, video, mixed
-  const CStdString& GetName() const { return m_playlistName; };
-  const CStdString& GetType() const { return m_playlistType; };
+  void SetName(const std::string &name);
+  void SetType(const std::string &type); // music, video, mixed
+  const std::string& GetName() const { return m_playlistName; };
+  const std::string& GetType() const { return m_playlistType; };
   bool IsVideoType() const;
   bool IsMusicType() const;
 
@@ -131,8 +134,8 @@ public:
   void SetOrderAttributes(SortAttribute attributes) { m_orderAttributes = attributes; }
   SortAttribute GetOrderAttributes() const { return m_orderAttributes; }
 
-  void SetGroup(const CStdString &group) { m_group = group; }
-  const CStdString& GetGroup() const { return m_group; }
+  void SetGroup(const std::string &group) { m_group = group; }
+  const std::string& GetGroup() const { return m_group; }
   void SetGroupMixed(bool mixed) { m_groupMixed = mixed; }
   bool IsGroupMixed() const { return m_groupMixed; }
 
@@ -144,16 +147,16 @@ public:
    \param referencedPlaylists a set of playlists to know when we reach a cycle
    \param needWhere whether we need to prepend the where clause with "WHERE "
    */
-  CStdString GetWhereClause(const CDatabase &db, std::set<CStdString> &referencedPlaylists) const;
-  void GetVirtualFolders(std::vector<CStdString> &virtualFolders) const;
+  std::string GetWhereClause(const CDatabase &db, std::set<std::string> &referencedPlaylists) const;
+  void GetVirtualFolders(std::vector<std::string> &virtualFolders) const;
 
-  CStdString GetSaveLocation() const;
+  std::string GetSaveLocation() const;
 
   static void GetAvailableFields(const std::string &type, std::vector<std::string> &fieldList);
 
-  static bool IsVideoType(const CStdString &type);
-  static bool IsMusicType(const CStdString &type);
-  static bool CheckTypeCompatibility(const CStdString &typeLeft, const CStdString &typeRight);
+  static bool IsVideoType(const std::string &type);
+  static bool IsMusicType(const std::string &type);
+  static bool CheckTypeCompatibility(const std::string &typeLeft, const std::string &typeRight);
 
   bool IsEmpty(bool ignoreSortAndLimit = true) const;
 
@@ -166,19 +169,19 @@ private:
 
   const TiXmlNode* readName(const TiXmlNode *root);
   const TiXmlNode* readNameFromPath(const CURL &url);
-  const TiXmlNode* readNameFromXml(const CStdString &xml);
+  const TiXmlNode* readNameFromXml(const std::string &xml);
   bool load(const TiXmlNode *root);
 
   CSmartPlaylistRuleCombination m_ruleCombination;
-  CStdString m_playlistName;
-  CStdString m_playlistType;
+  std::string m_playlistName;
+  std::string m_playlistType;
 
   // order information
   unsigned int m_limit;
   SortBy m_orderField;
   SortOrder m_orderDirection;
   SortAttribute m_orderAttributes;
-  CStdString m_group;
+  std::string m_group;
   bool m_groupMixed;
 
   CXBMCTinyXML m_xmlDoc;

diff --git a/xbmc/video/VideoDatabase.cpp b/xbmc/video/VideoDatabase.cpp
index 27b2815..d198f9a 100644 (file)
--- a/xbmc/video/VideoDatabase.cpp
+++ b/xbmc/video/VideoDatabase.cpp
@@ -9701,7 +9701,7 @@ bool CVideoDatabase::GetFilter(CDbUrl &videoUrl, Filter &filter, SortDescription
         // of the path (season and episodeid) appended later
        (xsp.GetType() == "episodes" && itemType == "tvshows"))
     {
-      std::set<CStdString> playlists;
+      std::set<std::string> playlists;
       filter.AppendWhere(xsp.GetWhereClause(*this, playlists));
 
       if (xsp.GetLimit() > 0)
@@ -9725,7 +9725,7 @@ bool CVideoDatabase::GetFilter(CDbUrl &videoUrl, Filter &filter, SortDescription
     // check if the filter playlist matches the item type
     if (xspFilter.GetType() == itemType)
     {
-      std::set<CStdString> playlists;
+      std::set<std::string> playlists;
       filter.AppendWhere(xspFilter.GetWhereClause(*this, playlists));
     }
     // remove the filter if it doesn't match the item type