}Phonebook::Phonebook(string phonebookName, Ref<GsmAt> at, MeTa &myMeTa,                     bool preload) throw(GsmException) :  _phonebookName(phonebookName), _at(at), _myMeTa(myMeTa), _useCache(true){  // select phonebook  _myMeTa.setPhonebook(_phonebookName);  // query size and maximum capacity of phonebook  _size = -1;                   // -1 means not known yet  _maxSize = -1;  Parser q(_at->chat("+CPBS?", "+CPBS:"));  string dummy = q.parseString();  if (q.parseComma(true))       // this means that  {                             // used and total result is supported by ME    _size = q.parseInt();    q.parseComma();    _maxSize = q.parseInt();  }    // get basic phonebook info from ME  Parser p(_at->chat("+CPBR=?", "+CPBR:"));  // get index of actually available entries in the phonebook  vector<bool> availablePositions = p.parseIntList();  p.parseComma();  _maxNumberLength = p.parseInt();  p.parseComma();  _maxTextLength = p.parseInt();    // find out capacity of phonebook in ME  // Note: The phonebook in the ME may be sparse, eg. the range of  // allowed index numbers may be something like (3-4, 20-100, 120).  // The standard allows this, even though it is unlikely to be   // implemented like that by anyone.  // In memory we store only phonebook entries that may actually be  // used, ie. the phonebook in memory is not sparse.  // Each entry has a member _index that corresponds to the index in the ME.  if (_maxSize == -1)  {    _maxSize = 0;    for (vector<bool>::iterator i = availablePositions.begin();         i != availablePositions.end(); ++i)      if (*i) ++_maxSize;  }  // for use with preload below  int *meToPhonebookIndexMap =    (int*)alloca(sizeof(int) * (availablePositions.size() + 1));  // initialize phone book entries  if (_maxSize == 0)    _phonebook = NULL;  else    _phonebook = new PhonebookEntry[_maxSize];  int nextAvailableIndex = 0;  int i;  for (i = 0; i < _maxSize; i++)  {    while (! availablePositions[nextAvailableIndex])      nextAvailableIndex++;    _phonebook[i]._index = nextAvailableIndex;    _phonebook[i]._cached = false;    _phonebook[i]._myPhonebook = this;    meToPhonebookIndexMap[nextAvailableIndex++] = i;  }  // find out first index number of phonebook  int firstIndex = -1;  for (i = 0; i < _maxSize; i++)    if (availablePositions[i])    {      firstIndex = i;      break;    }  // preload phonebook  // Note: this contains a workaround for the bug that  // some MEs can not return the entire phonebook with one AT command  // To detect this condition, _size must be known  // also, this code only handles non-sparse phonebooks  if (preload && _size != -1 &&       (int)availablePositions.size() == _maxSize + firstIndex)  {    int entriesRead = 0;    int startIndex = firstIndex;    while (entriesRead < _size)    {      reportProgress(0, _maxSize); // chatv also calls reportProgress()      vector<string> responses =        _at->chatv("+CPBR=" + intToStr(startIndex) +                   "," + intToStr(_maxSize + firstIndex - 1),                   "+CPBR:", true);      // this means that we have read nothing even though not all      // entries have been retrieved (entriesRead < _size)      // this could be due to a malfunction of the ME...      // anyway, missing entries can be read later by readEntry()      if (responses.size() == 0)      {#ifndef NDEBUG        if (debugLevel() >= 1)          cerr << "*** error when preloading phonebook: "            "not all entries returned" << endl;#endif        break;      }      for (vector<string>::iterator i = responses.begin();           i != responses.end(); ++i)      {        string telephone, text;        int meIndex = parsePhonebookEntry(*i, telephone, text);        _phonebook[meToPhonebookIndexMap[meIndex]]._cached = true;        _phonebook[meToPhonebookIndexMap[meIndex]]._telephone = telephone;        _phonebook[meToPhonebookIndexMap[meIndex]]._text = text;        assert(_phonebook[meToPhonebookIndexMap[meIndex]]._index == meIndex);        ++entriesRead;        startIndex = meIndex + 1;#ifndef NDEBUG        if (debugLevel() >= 1)          cerr << "*** Preloading PB entry " << meIndex               << " number " << telephone                << " text " << text << endl;#endif      }    }  }}Phonebook::iterator Phonebook::begin(){  return &_phonebook[0];}Phonebook::const_iterator Phonebook::begin() const{  return &_phonebook[0];}Phonebook::iterator Phonebook::end(){  return &_phonebook[_maxSize];}Phonebook::const_iterator Phonebook::end() const{  return &_phonebook[_maxSize];}Phonebook::reference Phonebook::operator[](int n){  return _phonebook[n];}Phonebook::const_reference Phonebook::operator[](int n) const{  return _phonebook[n];}Phonebook::reference Phonebook::front(){  return _phonebook[0];}Phonebook::const_reference Phonebook::front() const{  return _phonebook[0];}Phonebook::reference Phonebook::back(){  return _phonebook[_maxSize - 1];}Phonebook::const_reference Phonebook::back() const{  return _phonebook[_maxSize - 1];}int Phonebook::size() const throw(GsmException){  if (_size != -1)    return _size;  else  {    int result = 0;    for (int i = 0; i < _maxSize; i++)      if (! _phonebook[i].empty())        result++;    Phonebook *thisPhonebook = const_cast<Phonebook*>(this);    thisPhonebook->_size = result;    return result;  }}Phonebook::iterator Phonebook::insert(iterator position,                                      const PhonebookEntry& x)  throw(GsmException){  if (x.useIndex() && x.index() != -1)    return insert(x.telephone(), x.text(), x.index());  else    return insertFirstEmpty(x.telephone(), x.text());}void Phonebook::insert (iterator pos, int n, const PhonebookEntry& x)  throw(GsmException){  for (int i = 0; i < n; i++)    if (x.useIndex() && x.index() != -1)      insert(x.telephone(), x.text(), x.index());    else      insertFirstEmpty(x.telephone(), x.text());}void Phonebook::insert (iterator pos, long n, const PhonebookEntry& x)  throw(GsmException){  for (long i = 0; i < n; i++)    if (x.useIndex() && x.index() != -1)      insert(x.telephone(), x.text(), x.index());    else      insertFirstEmpty(x.telephone(), x.text());}Phonebook::iterator Phonebook::erase(iterator position)  throw(GsmException){  if (! position->empty())  {    position->set("", "");    adjustSize(-1);  }  return position + 1;}Phonebook::iterator Phonebook::erase(iterator first, iterator last)  throw(GsmException){  iterator i;  for (i = first; i != last; ++i)    erase(i);  return i;}void Phonebook::clear() throw(GsmException){  for (iterator i = begin(); i != end(); ++i)    erase(i);}Phonebook::iterator Phonebook::find(string text) throw(GsmException){  int index;  string telephone;  int i;  for (i = 0; i < _maxSize; i++)    if (_phonebook[i].text() == text)      return begin() + i;  findEntry(text, index, telephone);    for (i = 0; i < _maxSize; i++)    if (_phonebook[i].index() == index)      if (_phonebook[i].cached())      {        // if entry was already (= cached) and is now different        // the SIM card or it's contents were changed        if (_phonebook[i]._telephone != telephone ||            _phonebook[i]._text != text)          throw GsmException(_("SIM card changed while accessing phonebook"),                             OtherError);      }      else      {        _phonebook[i]._cached = true;        _phonebook[i]._telephone = telephone;        _phonebook[i]._text = text;        return begin() + i;      }  return end();}Phonebook::~Phonebook(){  delete []_phonebook;}