opensync-plugin/src/idmap.cc

   1 //
   2 // \file        idmap.cc
   3 //              Class that maps opensync UID strings to Blackberry
   4 //              Record ID's and back.
   5 //
   6
   7 /*
   8     Copyright (C) 2007-2013, Net Direct Inc. (http://www.netdirect.ca/)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "idmap.h"
  24 #include <fstream>
  25 #include "trace.h"
  26
  27 idmap::idmap()
  28         : m_blank_uid(""),
  29         m_blank_rid(0)
  30 {
  31 }
  32
  33 idmap::~idmap()
  34 {
  35 }
  36
  37 bool idmap::Load(const char *filename)
  38 {
  39         // start fresh
  40         m_map.clear();
  41
  42         std::ifstream ifs(filename);
  43         if( !ifs )
  44                 return false;
  45
  46         std::string line;
  47         uint32_t recordId;
  48         while( ifs ) {
  49                 recordId = 0;
  50                 ifs >> recordId >> std::ws;
  51                 std::getline(ifs, line);
  52                 if( ifs && recordId && line.size() ) {
  53                         Map(line, recordId);
  54                 }
  55         }
  56         return ifs.eof();
  57 }
  58
  59 bool idmap::Save(const char *filename) const
  60 {
  61         std::ofstream ofs(filename);
  62         if( !ofs )
  63                 return false;
  64
  65         const_iterator i = m_map.begin();
  66         for( ; i != m_map.end(); ++i ) {
  67                 ofs << i->second << " " << i->first << std::endl;
  68         }
  69         return !ofs.bad() && !ofs.fail();
  70 }
  71
  72 bool idmap::UidExists(const uid_type &uid, const_iterator *it) const
  73 {
  74         const_iterator i = m_map.find(uid);
  75         if( it )
  76                 *it = i;
  77         return i != m_map.end();
  78 }
  79
  80 bool idmap::RidExists(const rid_type &rid, const_iterator *it) const
  81 {
  82         const_iterator i = m_map.begin();
  83         for( ; i != m_map.end(); ++i ) {
  84                 if( i->second == rid ) {
  85                         if( it )
  86                                 *it = i;
  87                         return true;
  88                 }
  89         }
  90         if( it )
  91                 *it = m_map.end();
  92         return false;
  93 }
  94
  95 const idmap::uid_type& idmap::GetUid(const rid_type &rid) const
  96 {
  97         const_iterator i = m_map.begin();
  98         for( ; i != m_map.end(); ++i ) {
  99                 if( i->second == rid )
 100                         return i->first;
 101         }
 102         return m_blank_uid;
 103 }
 104
 105 const idmap::rid_type& idmap::GetRid(const uid_type &uid) const
 106 {
 107         const_iterator i = m_map.find(uid);
 108         return i->second;
 109 }
 110
 111 const idmap::uid_type& idmap::operator[] (const rid_type &rid) const
 112 {
 113         return GetUid(rid);
 114 }
 115
 116 const idmap::rid_type& idmap::operator[] (const uid_type &uid) const
 117 {
 118         return GetRid(uid);
 119 }
 120
 121 // returns map::end() if either id already exists, otherwise
 122 // returns newly mapped item iterator.
 123 //
 124 // The other versions of the function are to make conversion
 125 // between different types easier, giving ability to map
 126 // with any reasonable type, and then access the real
 127 // values through the iterator if needed.
 128 idmap::const_iterator idmap::Map(const uid_type &uid, const rid_type &rid)
 129 {
 130         // neither id can be blank
 131         if( uid.size() == 0 || rid == 0 )
 132                 return m_map.end();
 133
 134         // neither id must already exist
 135         if( UidExists(uid) || RidExists(rid) )
 136                 return m_map.end();
 137
 138         return m_map.insert(m_map.begin(), make_pair(uid, rid));
 139 }
 140
 141 /*
 142 idmap::const_iterator idmap::Map(unsigned long uid_number, const rid_type &rid)
 143 {
 144 }
 145
 146 idmap::const_iterator idmap::Map(unsigned long uid_number, const std::string &rid_string)
 147 {
 148 }
 149 */
 150
 151 void idmap::UnmapUid(const uid_type &uid)
 152 {
 153         m_map.erase(uid);
 154 }
 155
 156 void idmap::UnmapRid(const rid_type &rid)
 157 {
 158         iterator i = m_map.begin();
 159         for( ; i != m_map.end(); ++i ) {
 160                 if( i->second == rid ) {
 161                         m_map.erase(i);
 162                         return;
 163                 }
 164         }
 165 }
 166