fast in-place parse of a list of comma-delimited int values in a string SAM tag

str_split_pattern.cpp

char* str=brec->tag_str("ZD"); //let's say the tag is "ZD"
GVec<int> vals;
char* p=str; //slice start
for (int i=0;;++i) {
  char ch=str[i];
  if (ch==',') {
    str[i]=0;
    int v=atoi(p); //check for int parsing errors?
    vals.Add(v);
    p=str+i+1;
  } else if (ch==0) {
    int v=atoi(p); //check for int parsing errors?
    vals.Add(v);
    break;
  }
}
//now vals should have all parsed int values

Wondering if, for longer strings, using strchr is faster (if it's implemented with SSE optimization). In that case the code would look like this:

char* str=brec->tag_str("ZD"); //let's say the tag is "ZD"
GVec<int> vals;
char *p=str;
char *pd=NULL; //position of last delimiter found
while (1) {
   pd=strchr(p, ';');
   if (pd!=NULL) {
       *pd=0; //end the slice string
        int v=atoi(p);
        vals.Add(v);
        p=pd+1;
   }
   else {
        int v=atoi(p);
        vals.Add(v);
        break;
   }
}

In the case of multiple choices of a single-character delimiter, the code is very similar, using strpbrk(p, delim) instead of strchr(), where delim is a string with the set of characters which can be slice delimiters (e.g. char* delim=",;.:";).

If the delimiter is a string using strstr() is definitely the way to go (especially if it's SSE optimized, which it should be):

char* str=brec->tag_str("ZD"); //let's say the tag is "ZD"
GVec<int> vals;
char *p=str;
char *pd=NULL; //position of last delimiter found
const char* delim="^^";
int dlen=strlen(delim);
while (1) {
   pd=strstr(p, delim);
   if (pd!=NULL) {
       *pd=0; //end the slice string
        int v=atoi(p);
        vals.Add(v);
        p=pd+dlen;
   }
   else {
        int v=atoi(p);
        vals.Add(v);
        break;
   }
}