src/DAL/Keys.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include "Keys.h"
  22 #include "KeyValue.h"
  23 #include "KeyImpl.h"
  24 #include "TableImpl.h"
  25 #include "FieldImpl.h"
  26 #include "Parse.h"
  27 #include "StringUtilities.h"
  28
  29 Keys::Keys(TableImplPtr table) :
  30 m_table(table)
  31 {
  32         Assert(table);
  33 }
  34
  35 Keys::Keys(TableImplPtr table, cstring initstring) :
  36 m_table(table)
  37 {
  38         Assert(table);
  39         Parse p(initstring);
  40
  41         try
  42         {
  43                 for(FieldImplVector::const_iterator it = m_table->begin(); it != m_table->end(); it++)
  44                 {
  45                         FieldImplPtr field = *it;
  46                         Assert(field);
  47
  48                         if(!field->isPrimaryKey())
  49                                 continue;
  50
  51                         KeyImplPtr keyimpl = boost::static_pointer_cast<KeyImpl>(field);
  52                         Assert(keyimpl);
  53
  54                         std::string keystring = p.getword();
  55                         int value = atoi(keystring.c_str());
  56                         KeyValuePtr key(new KeyValue(keyimpl, value));
  57
  58                         addKey(key);
  59                 }
  60         }
  61         catch(std::exception& e)
  62         {
  63                 throw std::invalid_argument("Keys::Keys(), could not parse initstring.");
  64         }
  65 }
  66
  67 Keys::~Keys()
  68 {
  69
  70 }
  71
  72 KeyValuePtr Keys::getKey(KeyImplPtr key) const
  73 {
  74         Assert(key);
  75         KeyImplMap::const_iterator it = m_keys.find(key.get());
  76         Assert(it != m_keys.end());
  77
  78         return it->second;
  79 }
  80
  81 TableImplPtr Keys::getTable() const
  82 {
  83         return m_table;
  84 }
  85
  86 void Keys::addKey(KeyValuePtr key)
  87 {
  88         Assert(key);
  89         Assert(key->getTable() == m_table);
  90         Assert(key->isPrimaryKey());
  91
  92         KeyImpl* keyimpl = key->getKeyImpl().get();
  93         m_keys[keyimpl] = key;
  94 }
  95
  96 void Keys::addKey(KeyImplPtr keyimpl, value_type id)
  97 {
  98         Assert(keyimpl);
  99         Assert(id);
 100         Assert(keyimpl->getTable() == m_table);
 101
 102         KeyValuePtr key(new KeyValue(keyimpl, id));
 103
 104         m_keys[key->getKeyImpl().get()] = key;
 105 }
 106
 107 std::string Keys::toString() const
 108 {
 109         std::string result;
 110
 111         for(KeyImplMap::const_iterator it = m_keys.begin(); it != m_keys.end(); it++)
 112         {
 113                 if(it != m_keys.begin())
 114                         result.append(", ");
 115
 116                 KeyValuePtr key = it->second;
 117                 result.append(String::Get()->fromInt(key->getIntegerValue()));
 118         }
 119
 120         return result;
 121 }
 122
 123 size_t Keys::size() const
 124 {
 125         return m_keys.size();
 126 }
 127
 128 KeyValuePtr Keys::first() const
 129 {
 130         Assert(m_keys.size() == 1);
 131         KeyValuePtr key = m_keys.begin()->second;
 132         return key;
 133 }
 134
 135 KeyImplMap::const_iterator Keys::begin() const
 136 {
 137         return m_keys.begin();
 138 }
 139
 140 KeyImplMap::const_iterator Keys::end() const
 141 {
 142         return m_keys.end();
 143 }
 144
 145 KeyImplMap::const_iterator Keys::find(KeyImplPtr key) const
 146 {
 147         Assert(key);
 148
 149         return m_keys.find(key.get());
 150 }
 151
 152 void Keys::setDirty(KeysPtr oldKeys)
 153 {
 154         for(KeyImplMap::iterator it = m_keys.begin(); it != m_keys.end(); it++)
 155         {
 156                 KeyValuePtr key = it->second;
 157                 KeyImplMap::const_iterator other = oldKeys->find(key->getKeyImpl());
 158
 159                 // new key (previously empty)
 160                 if(other == oldKeys->end())
 161                 {
 162                         key->setDirty(true);
 163                         continue;
 164                 }
 165
 166                 KeyValuePtr otherKey = other->second;
 167                 if(key->getIntegerValue() != otherKey->getIntegerValue())
 168                         key->setDirty(true);
 169         }
 170 }
 171
 172 Strings Keys::getDiff(KeysPtr orig) const
 173 {
 174         Strings result;
 175
 176         for(KeyImplMap::const_iterator it = m_keys.begin(); it != m_keys.end(); it++)
 177         {
 178                 KeyValuePtr key = it->second;
 179                 Assert(key);
 180                 if(!key->isDirty())
 181                         continue;
 182
 183                 KeyImplPtr keyimpl = key->getKeyImpl();
 184                 Assert(keyimpl);
 185
 186                 KeyValuePtr origKey = orig->getKey(keyimpl);
 187                 Assert(origKey);
 188
 189                 std::string line = "Changed key '";
 190                 line.append(keyimpl->getName());
 191                 line.append("' from '");
 192                 line.append(String::Get()->fromInt(origKey->getIntegerValue()));
 193                 line.append("' to '");
 194                 line.append(String::Get()->fromInt(key->getIntegerValue()));
 195                 line.append("'.");
 196
 197                 result.push_back(line);
 198         }
 199
 200         return result;
 201 }