IdentifierField.h File Reference

#include <Identifier/ExpandedIdentifier.h>
#include <vector>
#include <string>
#include <stdexcept>
#include <iostream>
#include <limits>
#include <utility>
#include <variant>

Include dependency graph for IdentifierField.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	IdentifierField
	This is the individual specification for the range of one ExpandedIdentifier IdentifierField. More...

Functions
std::ostream &	operator<< (std::ostream &out, const IdentifierField &c)
std::istream &	operator>> (std::istream &in, IdentifierField &c)

Function Documentation

operator<<()

std::ostream & operator<<	(	std::ostream &	out,
		const IdentifierField &	c )

Definition at line 489 of file IdentifierField.cxx.

                                                       {
  out<<std::string(c);
  return out;
}

operator>>()

std::istream & operator>>	(	std::istream &	in,
		IdentifierField &	c )

Definition at line 497 of file IdentifierField.cxx.

                                                  {
  idf.clear();
  while (std::isspace(is.peek())){is.ignore();}
  char c = is.peek();
  if (c =='*'){
    is.ignore();
    //do nothing; the 'clear' set idf to unbounded
  } else if (isDigit(c)){
    if (c =='+') is.ignore();
    int v = parseStreamDigits(is);//'is' ptr is incremented
    c = is.peek();
    //possible:  bound, list
    if (c == ','){ //found comma, so definitely list
      is.ignore();
      std::vector<int> vec(1,v);
      const auto  & restOfList = parseStreamList(is);
      vec.insert(vec.end(), restOfList.begin(), restOfList.end());
      idf.set(vec);
    } else if (c == ':'){ //bounded
      is.ignore();
      c=is.peek(); //peek char after the colon
      if (isDigit(c)){ //bounded
        int v1 = parseStreamDigits(is);
        idf.set(v,v1);
      } 
    } else { //remaining alternative: single number
      idf.add_value(v);
    }
  } else {
    std::string msg{"Stream extraction for IdentifierField: "};
    std::string remains;
    is >> remains;
    msg+=remains;
    throw std::invalid_argument(msg);
  }
  return is;
}