source: src/Formula.cpp@ add42a

/*
 * Formula.cpp
 *
 *  Created on: Jul 21, 2010
 *      Author: crueger
 */

#include "Formula.hpp"

#include <sstream>
#include <iostream>

#include "World.hpp"
#include "periodentafel.hpp"
#include "element.hpp"
#include "Helpers/Assert.hpp"

using namespace std;

Formula::Formula() :
  numElements(0)
{}

Formula::Formula(const Formula &src) :
  elementCounts(src.elementCounts),
  numElements(src.numElements)
{}

Formula::Formula(const string &formula) :
  numElements(0)
{
  fromString(formula);
}

Formula::~Formula()
{}

Formula &Formula::operator=(const Formula &rhs){
  // No self-assignment check needed
  elementCounts=rhs.elementCounts;
  numElements=rhs.numElements;
  return *this;
}

std::string Formula::toString() const{
  stringstream sstr;
  for(const_iterator iter=end();iter!=begin();){
    --iter;
    sstr << (*iter).first->symbol;
    if((*iter).second>1)
      sstr << (*iter).second;
  }
  return sstr.str();
}

// quick function used for parsing
bool isInRange(pair<char,char> range,char character){
  return range.first<=character && character<=range.second;
}

void Formula::fromString(const std::string &formula) throw(ParseError){
  // some constants needed for parsing... Assumes ASCII, change if other encodings are used
  static const pair<char,char> CapitalLetters = make_pair('A','Z');
  static const pair<char,char> SmallLetters = make_pair('a','z');
  static const pair<char,char> Numbers = make_pair('0','9');
  // clean the formula
  clear();
  string::const_iterator end = formula.end(); // will be used frequently
  for(string::const_iterator it=formula.begin();it!=end;){
    string shorthand;
    // Atom names start with a capital letter
    if(!isInRange(CapitalLetters,(*it)))
      throw(ParseError(__FILE__,__LINE__));
    shorthand+=(*it++);
    cout << "Beginning of shorthand read: " << shorthand << endl;
    // the rest of the name follows
    while(it!=end && isInRange(SmallLetters,(*it)))
      shorthand+=(*it++);
    cout << "Full shorthand read: " << shorthand << endl;
    // now we can count the occurences
    int count = 0;
    while(it!=end && isInRange(Numbers,(*it)))
      count = (count*10) + ((*it++)-Numbers.first);
    cout << "Count read: " << count << endl;
    // one is implicit
    count = (count!=0)?count:1;
    cout << "Corrected implicit count: " << count << endl;
    // done, we can get the next one
    addElements(shorthand,count);
  }
}

bool Formula::checkOut(ostream *output) const{
  bool result = true;
  int No = 1;

  if (output != NULL) {
    *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
    *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
    for(const_iterator iter=begin(); iter!=end();++iter){
      (*iter).first->No = No;
      result = result && (*iter).first->Checkout(output, No++, (*iter).second);
    }
    return result;
  } else
    return false;
}

unsigned int Formula::getElementCount() const{
  return numElements;
}

bool Formula::hasElement(const element *element) const{
  ASSERT(element,"Invalid pointer in Formula::hasElement(element*)");
  return hasElement(element->getNumber());
}

bool Formula::hasElement(atomicNumber_t Z) const{
  ASSERT(Z>0,"Invalid atomic Number");
  ASSERT(World::getInstance().getPeriode()->FindElement(Z),"No Element with this number in Periodentafel");
  return elementCounts.size()>=Z && elementCounts[Z-1];
}

bool Formula::hasElement(const string &shorthand) const{
  element * element = World::getInstance().getPeriode()->FindElement(shorthand);
  return hasElement(element);
}

void Formula::operator+=(const element *element){
  ASSERT(element,"Invalid pointer in increment of Formula");
  operator+=(element->getNumber());
}

void Formula::operator+=(atomicNumber_t Z){
  ASSERT(Z>0,"Invalid atomic Number");
  ASSERT(World::getInstance().getPeriode()->FindElement(Z),"No Element with this number in Periodentafel");
  elementCounts.resize(Z); // No-op when we already have the right size
  // might need to update number of elements
  if(!elementCounts[Z-1]){
    numElements++;
  }
  elementCounts[Z-1]++;    // atomic numbers start at 1
}

void Formula::operator+=(const string &shorthand){
  element * element = World::getInstance().getPeriode()->FindElement(shorthand);
  operator+=(element);
}

void Formula::operator-=(const element *element){
  ASSERT(element,"Invalid pointer in decrement of Formula");
  operator-=(element->getNumber());
}

void Formula::operator-=(atomicNumber_t Z){
  ASSERT(Z>0,"Invalid atomic Number");
  ASSERT(World::getInstance().getPeriode()->FindElement(Z),"No Element with this number in Periodentafel");
  ASSERT(elementCounts.size()>=Z && elementCounts[Z-1], "Element not in Formula upon decrement");
  elementCounts[Z-1]--;    // atomic numbers start at 1
  // might need to update number of elements
  if(!elementCounts[Z-1]){
    numElements--;
  }
}

void Formula::operator-=(const string &shorthand){
  element * element = World::getInstance().getPeriode()->FindElement(shorthand);
  operator-=(element);
}

void Formula::addElements(const element *element,unsigned int count){
  ASSERT(element,"Invalid pointer in Formula::addElements(element*)");
  addElements(element->getNumber(),count);
}

void Formula::addElements(atomicNumber_t Z,unsigned int count){
  if(count==0) return;
  ASSERT(Z>0,"Invalid atomic Number");
  ASSERT(World::getInstance().getPeriode()->FindElement(Z),"No Element with this number in Periodentafel");
  elementCounts.resize(Z); // No-op when we already have the right size
  cout << "Adding " << count << " to element with number " << Z << endl;
  // might need to update number of elements
  if(!elementCounts[Z-1]){
    numElements++;
  }
  elementCounts[Z-1]+=count;
  cout << "Element ist now " << elementCounts[Z-1] << endl;
}

void Formula::addElements(const string &shorthand,unsigned int count){
  element * element = World::getInstance().getPeriode()->FindElement(shorthand);
  addElements(element,count);
}

const unsigned int Formula::operator[](const element *element) const{
  ASSERT(element,"Invalid pointer in access of Formula");
  return operator[](element->getNumber());
}

const unsigned int Formula::operator[](atomicNumber_t Z) const{
  ASSERT(Z>0,"Invalid atomic Number");
  ASSERT(World::getInstance().getPeriode()->FindElement(Z),"No Element with this number in Periodentafel");
  if(elementCounts.size()<Z)
    return 0;
  return elementCounts[Z-1]; // atomic numbers start at 1
}

const unsigned int Formula::operator[](string shorthand) const{
  element * element = World::getInstance().getPeriode()->FindElement(shorthand);
  return operator[](element);
}

bool Formula::operator==(const Formula &rhs) const{
  // quick check... number of elements used
  if(numElements != rhs.numElements){
    return false;
  }
  // slow check: all elements
  // direct access to internal structure means all element-counts have to be compared
  // this avoids access to periodentafel to find elements though and is probably faster
  // in total
  return equal(elementCounts.begin(),
               elementCounts.end(),
               rhs.elementCounts.begin());
}

bool Formula::operator!=(const Formula &rhs) const{
  return !operator==(rhs);
}

Formula::iterator Formula::begin(){
  return iterator(elementCounts,0);
}
Formula::const_iterator Formula::begin() const{
  return const_iterator(elementCounts,0);
}
Formula::iterator Formula::end(){
  return iterator(elementCounts);
}
Formula::const_iterator Formula::end() const{
  return const_iterator(elementCounts);
}

void Formula::clear(){
  elementCounts.clear();
  numElements = 0;
}

/**************** Iterator structure ********************/

template <class result_type>
Formula::_iterator<result_type>::_iterator(set_t &_set) :
    set(&_set)
{
  pos=set->size();
}

template <class result_type>
Formula::_iterator<result_type>::_iterator(set_t &_set,size_t _pos) :
  set(&_set),pos(_pos)
{
  ASSERT(pos<=set->size(),"invalid position in iterator construction");
  while(pos<set->size() && (*set)[pos]==0) ++pos;
}

template <class result_type>
Formula::_iterator<result_type>::_iterator(const _iterator &rhs) :
  set(rhs.set),pos(rhs.pos)
{}

template <class result_type>
Formula::_iterator<result_type>::~_iterator(){}

template <class result_type>
Formula::_iterator<result_type>&
Formula::_iterator<result_type>::operator=(const _iterator<result_type> &rhs){
  set=rhs.set;
  pos=rhs.pos;
  return *this;
}

template <class result_type>
bool
Formula::_iterator<result_type>::operator==(const _iterator<result_type> &rhs){
  return set==rhs.set && pos==rhs.pos;
}

template <class result_type>
bool
Formula::_iterator<result_type>::operator!=(const _iterator<result_type> &rhs){
  return !operator==(rhs);
}

template <class result_type>
Formula::_iterator<result_type>
Formula::_iterator<result_type>::operator++(){
  ASSERT(pos!=set->size(),"Incrementing Formula::iterator beyond end");
  pos++;
  while(pos<set->size() && (*set)[pos]==0) ++pos;
  return *this;
}

template <class result_type>
Formula::_iterator<result_type>
Formula::_iterator<result_type>::operator++(int){
  Formula::_iterator<result_type> retval = *this;
  ++(*this);
  return retval;
}

template <class result_type>
Formula::_iterator<result_type>
Formula::_iterator<result_type>::operator--(){
  ASSERT(pos!=0,"Decrementing Formula::iterator beyond begin");
  pos--;
  while(pos>0 && (*set)[pos]==0) --pos;
  return *this;
}

template <class result_type>
Formula::_iterator<result_type>
Formula::_iterator<result_type>::operator--(int){
  Formula::_iterator<result_type> retval = *this;
  --(*this);
  return retval;
}

template <class result_type>
result_type
Formula::_iterator<result_type>::operator*(){
  element *element = World::getInstance().getPeriode()->FindElement(pos+1);
  ASSERT(element,"Element with position of iterator not found");
  return make_pair(element,(*set)[pos]);
}

template <class result_type>
result_type*
Formula::_iterator<result_type>::operator->(){
  // no one can keep this value around, so a static is ok to avoid temporaries
  static value_type value=make_pair(reinterpret_cast<element*>(0),0); // no default constructor for std::pair
  element *element = World::getInstance().getPeriode()->FindElement(pos+1);
  ASSERT(element,"Element with position of iterator not found");
  value = make_pair(element,(*set)[pos]);
  return &value;
}

// explicit instantiation of all iterator template methods
// this is quite ugly, but there is no better way unless we expose iterator implementation

// instantiate Formula::iterator
template Formula::_iterator<Formula::value_type>::_iterator(set_t&);
template Formula::_iterator<Formula::value_type>::_iterator(set_t&,size_t);
template Formula::_iterator<Formula::value_type>::_iterator(const Formula::_iterator<Formula::value_type>&);
template Formula::_iterator<Formula::value_type>::~_iterator();
template Formula::_iterator<Formula::value_type> &Formula::_iterator<Formula::value_type>::operator=(const _iterator &);
template bool Formula::_iterator<Formula::value_type>::operator==(const _iterator&);
template bool Formula::_iterator<Formula::value_type>::operator!=(const _iterator&);
template Formula::_iterator<Formula::value_type> Formula::_iterator<Formula::value_type>::operator++();
template Formula::_iterator<Formula::value_type> Formula::_iterator<Formula::value_type>::operator++(int);
template Formula::_iterator<Formula::value_type> Formula::_iterator<Formula::value_type>::operator--();
template Formula::_iterator<Formula::value_type> Formula::_iterator<Formula::value_type>::operator--(int);
template Formula::value_type Formula::_iterator<Formula::value_type>::operator*();
template Formula::value_type *Formula::_iterator<Formula::value_type>::operator->();

// instantiate Formula::const_iterator
template Formula::_iterator<const Formula::value_type>::_iterator(set_t&);
template Formula::_iterator<const Formula::value_type>::_iterator(set_t&,size_t);
template Formula::_iterator<const Formula::value_type>::_iterator(const Formula::_iterator<const Formula::value_type>&);
template Formula::_iterator<const Formula::value_type>::~_iterator();
template Formula::_iterator<const Formula::value_type> &Formula::_iterator<const Formula::value_type>::operator=(const _iterator &);
template bool Formula::_iterator<const Formula::value_type>::operator==(const _iterator&);
template bool Formula::_iterator<const Formula::value_type>::operator!=(const _iterator&);
template Formula::_iterator<const Formula::value_type> Formula::_iterator<const Formula::value_type>::operator++();
template Formula::_iterator<const Formula::value_type> Formula::_iterator<const Formula::value_type>::operator++(int);
template Formula::_iterator<const Formula::value_type> Formula::_iterator<const Formula::value_type>::operator--();
template Formula::_iterator<const Formula::value_type> Formula::_iterator<const Formula::value_type>::operator--(int);
template const Formula::value_type Formula::_iterator<const Formula::value_type>::operator*();
template const Formula::value_type *Formula::_iterator<const Formula::value_type>::operator->();

/********************** I/O of Formulas ************************************************/

std::ostream &operator<<(std::ostream &ost,const Formula &formula){
  ost << formula.toString();
  return ost;
}