roiname.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "tpcextensions.h"
/*****************************************************************************/
 
/*****************************************************************************/
char *roinameSubpart(
  const char *roiname,
  const char *dlm,
  const unsigned int si,
  char *subpart,
  const unsigned int slen
) {
  if(subpart==NULL || slen<1) return(subpart);
  subpart[0]=(char)0;
  if(roiname==NULL || strnlen(roiname, 1)==0) return((char*)NULL);
  if(dlm==NULL || strnlen(dlm, 1)==0) return((char*)NULL);
 
  unsigned int i=0;
  char *s=strdup(roiname);
  char *sp=s; //printf(" si=%d\n", si);
  do {
    //printf("  sp='%s'\n", sp);
    char *p=strpbrk(sp, dlm);
    //printf("  i=%d  p='%s'\n", i, p);
    if(!p) {
      if(si==i) {strlcat(subpart, sp, slen); free(s); return(subpart);}
      free(s); return((char*)NULL);
    }
    *p=(char)0;
    if(si==i) {strlcat(subpart, sp, slen); free(s); return(subpart);}
    sp=p+1; i++;
  } while(*sp);  
 
  if(si==i) {strlcat(subpart, sp, slen); free(s); return(subpart);}
  free(s);
  return((char*)NULL);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *roinameEditByTemplate(
  const char *template,
  const char *currname,
  char *newname,
  const unsigned int count 
) {
  if(newname==NULL || count<1) return((char*)NULL);
  newname[0]=(char)0;
  if(template==NULL || currname==NULL) return((char*)NULL);
  
  unsigned int i, len;
  len=strlen(template); i=strlen(currname); if(i>len) len=i;
  if(len<1) return(newname);
  char subpart[++len], *c;
  
  i=0;
  c=roinameSubpart(template, "_", i, subpart, len);
  while(c) {
    /* If not '@' or if '@' can be replaced with sub-part from original tacname, then copy */
    if(strcmp(subpart, "@")!=0 || roinameSubpart(currname, " _", i, subpart, 256)) {
      if(i>0) strlcat(newname, "_", count);
      strlcat(newname, subpart, count);
    }
    c=roinameSubpart(template, "_", ++i, subpart, 256);
  }
  return(newname);
}
/*****************************************************************************/
 
/*****************************************************************************/
char *roinameAddField(
  char *roiname, 
  const char *field, 
  const unsigned int in,
  const unsigned int count
) {
  if(roiname==NULL) return(roiname);
  if(field==NULL) return((char*)NULL);
  unsigned int slen=strlen(roiname);
  unsigned int flen=strlen(field);
  if(count < (slen+flen+2)) return((char*)NULL);
  if(slen==0) {
    if(flen==0) {strlcpy(roiname, "_", count); return(roiname);}
    else {strlcpy(roiname, field, count); return(roiname);}
  }
 
  char *c, subpart[slen+1], tmp[slen+1];
  unsigned int i=0;
  strcpy(tmp, roiname); strcpy(roiname, "");
  c=roinameSubpart(tmp, " _", i, subpart, slen+1);
  while(c) {
    if(i==in) {
      if(i>0) strlcat(roiname, "_", count);
      strlcat(roiname, field, count);
    }  
    if(i>0 || i==in) strlcat(roiname, "_", count);
    strlcat(roiname, subpart, count);
    c=roinameSubpart(tmp, " _", ++i, subpart, slen+1);
  }
  if(i<=in) {
    if(i>0) strlcat(roiname, "_", count);
    strlcat(roiname, field, count);
  }
  return(roiname);
}  
/*****************************************************************************/
 
/*****************************************************************************/
int roinameExists(
  char *roiname
) {
  if(roiname==NULL) return(0);
  size_t len, n;
  len=strlen(roiname); if(len==0) return(0);
  n=strspn(roiname, " _-.\t"); if(n==len) return(0);
  return(1);
}
/*****************************************************************************/
 
/*****************************************************************************/
int roinameMatch(
  const char *roiname,
  const char *test_str,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  /* If both string are empty, then that is a match */
  if((roiname==NULL || strlen(roiname)<1) && (test_str==NULL || strlen(test_str)<1)) {
    return(1);
  } 
  /* If just either of those is empty, then that is a no match */
  if(roiname==NULL || strlen(roiname)<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(0);
  }
  if(test_str==NULL || strlen(test_str)<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(0);
  }
 
  /* Check the number of name sub-parts */
  int i, len;
  len=strlen(roiname); i=strlen(test_str); if(i>len) len=i;
  char subn1[len+1], subn2[len+1];
  int roisubnr=0, refsubnr=0;
  for(i=0; i<6; i++) {
    if(roinameSubpart(roiname, " _-", i, subn1, len+1)==NULL) break; 
    roisubnr++;
  }
  for(i=0; i<6; i++) {
    if(roinameSubpart(test_str, " _-", i, subn2, len+1)==NULL) break; 
    refsubnr++;
  }
  if(verbose>3) printf("roisubnr := %d\nrefsubnr := %d\n", roisubnr, refsubnr);
  if(roisubnr==0 && refsubnr==0) return(1);
  if(roisubnr==0 || refsubnr==0) return(0);
  if(refsubnr>1 && roisubnr!=refsubnr) return(0);
  
  /* If more than one sub-name to test for, then test against corresponding sub-names with 
     wild cards */
  if(refsubnr>1) {
    for(i=0; i<refsubnr; i++) {
      roinameSubpart(roiname, " _-", i, subn1, len+1); 
      if(!strcmp(subn1, ".")) strcpy(subn1, "");
      roinameSubpart(test_str, " _-", i, subn2, len+1);
      if(!strcmp(subn2, ".")) strcpy(subn2, "");
      if(verbose>3) printf(" '%s' vs '%s'\n", subn1, subn2);
      if(strnlen(subn1, 1)==0 && strnlen(subn2, 1)==0) continue;
      if(strnlen(subn2, 1)<1 || fncasematch(subn1, subn2)==0 ) return(0);
    }
    return(1);
  }
 
  /* So, we have just one sub-name in the test string */
  /* If it is found in any of sub names, accepting wild cards, then we consider it a match */
  if(roinameSubpart(test_str, " _-", 0, subn2, len+1)==NULL) return(0);
  if(!strcmp(subn2, ".")) strcpy(subn2, "");
  for(i=0; i<roisubnr; i++) {
    if(roinameSubpart(roiname, " _-", i, subn1, len+1)==NULL) continue;
    if(!strcmp(subn1, ".")) strcpy(subn1, "");
    if(fncasematch(subn1, subn2)) return(1);
  }
  return(0);
}
/*****************************************************************************/
 
/*****************************************************************************/