do not translate empty string

[enigma2.git] / lib / dvb / db.cpp

diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp
index 64ef6ed7bf818ecb7068c1ddedb8420eee130849..529204737274d976f764c19a5e8afff8b3e8b84c 100644 (file)
--- a/lib/dvb/db.cpp
+++ b/lib/dvb/db.cpp
@@ -12,13 +12,19 @@
 
 DEFINE_REF(eDVBService);
 
-RESULT eBouquet::addService(const eServiceReference &ref)
+RESULT eBouquet::addService(const eServiceReference &ref, eServiceReference before)
 {
        list::iterator it =
                std::find(m_services.begin(), m_services.end(), ref);
        if ( it != m_services.end() )
                return -1;
-       m_services.push_back(ref);
+       if (before.valid())
+       {
+               it = std::find(m_services.begin(), m_services.end(), before);
+               m_services.insert(it, ref);
+       }
+       else
+               m_services.push_back(ref);
        return 0;
 }
 
@@ -114,21 +120,13 @@ RESULT eBouquet::setListName(const std::string &name)
 }
 
 eDVBService::eDVBService()
-       :m_flags(0)
+       :m_cache(0), m_flags(0)
 {
-       memset(m_cache, -1, sizeof(m_cache));
 }
 
 eDVBService::~eDVBService()
 {
-}
-
-bool eDVBService::cacheEmpty()
-{
-       for (int i=0; i < cacheMax; ++i)
-               if (m_cache[i] != -1)
-                       return false;
-       return true;
+       delete [] m_cache;
 }
 
 eDVBService &eDVBService::operator=(const eDVBService &s)
@@ -137,8 +135,8 @@ eDVBService &eDVBService::operator=(const eDVBService &s)
        m_service_name_sort = s.m_service_name_sort;
        m_provider_name = s.m_provider_name;
        m_flags = s.m_flags;
-//     m_ca = s.m_ca;
-       memcpy(m_cache, s.m_cache, sizeof(m_cache));
+       m_ca = s.m_ca;
+       copyCache(s.m_cache);
        return *this;
 }
 
@@ -232,15 +230,47 @@ int eDVBService::checkFilter(const eServiceReferenceDVB &ref, const eDVBChannelQ
                return res;
 }
 
-int eDVBService::getCachePID(cacheID id)
+bool eDVBService::cacheEmpty()
+{
+       if (m_cache)
+               for (int i=0; i < cacheMax; ++i)
+                       if (m_cache[i] != -1)
+                               return false;
+       return true;
+}
+
+void eDVBService::initCache()
+{
+       m_cache = new int[cacheMax];
+       memset(m_cache, -1, sizeof(int) * cacheMax);
+}
+
+void eDVBService::copyCache(int *source)
+{
+       if (source)
+       {
+               if (!m_cache)
+                       m_cache = new int[cacheMax];
+               memcpy(m_cache, source, cacheMax * sizeof(int));
+       }
+       else
+       {
+               delete [] m_cache;
+               m_cache = 0;
+       }
+}
+
+int eDVBService::getCacheEntry(cacheID id)
 {
-       if (id >= cacheMax)
+       if (id >= cacheMax || !m_cache)
                return -1;
        return m_cache[id];
 }
 
-void eDVBService::setCachePID(cacheID id, int pid)
+void eDVBService::setCacheEntry(cacheID id, int pid)
 {
+       if (!m_cache)
+               initCache();
        if (id < cacheMax)
                m_cache[id] = pid;
 }
@@ -426,13 +456,13 @@ void eDVBDB::reloadServicelist()
                                {
                                        int cid, val;
                                        sscanf(v.c_str(), "%02d%04x", &cid, &val);
-                                       s->m_cache[cid]=val;
-                               }/* else if (p == 'C')
+                                       s->setCacheEntry((eDVBService::cacheID)cid,val);
+                               } else if (p == 'C')
                                {
                                        int val;
                                        sscanf(v.c_str(), "%04x", &val);
-                                       s->m_ca.insert(val);
-                               }*/
+                                       s->m_ca.push_front((uint16_t)val);
+                               }
                        }
                addService(ref, s);
        }
@@ -517,15 +547,16 @@ void eDVBDB::saveServicelist()
 
                // write cached pids
                for (int x=0; x < eDVBService::cacheMax; ++x)
-                       if (i->second->m_cache[x] != -1)
-                               fprintf(f, ",c:%02d%04x", x, i->second->m_cache[x]);
+               {
+                       int entry = i->second->getCacheEntry((eDVBService::cacheID)x);
+                       if (entry != -1)
+                               fprintf(f, ",c:%02d%04x", x, entry);
+               }
 
-/*
                // write cached ca pids
-               for (std::set<int>::const_iterator ca(i->second->m_ca.begin());
+               for (CAID_LIST::const_iterator ca(i->second->m_ca.begin());
                        ca != i->second->m_ca.end(); ++ca)
                        fprintf(f, ",C:%04x", *ca);
-*/
 
                if (i->second->m_flags)
                        fprintf(f, ",f:%x", i->second->m_flags);
@@ -984,21 +1015,43 @@ eDVBDBQueryBase::eDVBDBQueryBase(eDVBDB *db, const eServiceReference &source, eD
 int eDVBDBQueryBase::compareLessEqual(const eServiceReferenceDVB &a, const eServiceReferenceDVB &b)
 {
        ePtr<eDVBService> a_service, b_service;
-       
        int sortmode = m_query ? m_query->m_sort : eDVBChannelQuery::tName;
        
        if ((sortmode == eDVBChannelQuery::tName) || (sortmode == eDVBChannelQuery::tProvider))
        {
-               if (m_db->getService(a, a_service))
+               if (a.name.empty() && m_db->getService(a, a_service))
                        return 1;
-               if (m_db->getService(b, b_service))
+               if (b.name.empty() && m_db->getService(b, b_service))
                        return 1;
        }
        
        switch (sortmode)
        {
        case eDVBChannelQuery::tName:
-               return a_service->m_service_name_sort < b_service->m_service_name_sort;
+               if (a_service)
+               {
+                       if (b_service)
+                               return a_service->m_service_name_sort < b_service->m_service_name_sort;
+                       else
+                       {
+                               std::string str = b.name;
+                               makeUpper(str);
+                               return a_service->m_service_name_sort < str;
+                       }
+               }
+               else if (b_service)
+               {
+                       std::string str = a.name;
+                       makeUpper(str);
+                       return str < b_service->m_service_name_sort;
+               }
+               else
+               {
+                       std::string aa = a.name, bb = b.name;
+                       makeUpper(aa);
+                       makeUpper(bb);
+                       return aa < bb;
+               }
        case eDVBChannelQuery::tProvider:
                return a_service->m_provider_name < b_service->m_provider_name;
        case eDVBChannelQuery::tType:
@@ -1095,7 +1148,10 @@ int eDVBDBListQuery::compareLessEqual(const eServiceReferenceDVB &a, const eServ
                        y -= 3600;
                return x < y;
        }
-       return a.name < b.name;
+       std::string aa = a.name, bb = b.name;
+       makeUpper(aa);
+       makeUpper(bb);
+       return aa < bb;
 }
 
 eDVBDBSatellitesQuery::eDVBDBSatellitesQuery(eDVBDB *db, const eServiceReference &source, eDVBChannelQuery *query)