xmlbasics.cc

XMDS is a code generator that integrates equations. You write them down in human readable form in a

};

// **********************************************************************
void XMLString::insertString(
			     const unsigned long& offset,
			     const XMLString& s) {

  if(offset > _length) {
    return;
  }

  unsigned long newLength = _length + s._length;
  char* newData = new char[newLength];

  unsigned long i;
  for(i = 0; i < offset; i++) {
    newData[i] = _data[i];
  }
  for(i = 0; i < s._length; i++) {
    newData[offset + i] = s._data[i];
  }
  for(i = offset; i < _length; i++) {
    newData[offset + s._length + i] = _data[i];
  }

  if(_length) {
    delete _data;
  }
  _data = newData;
  _length = newLength;

  if(_c_str_valid) {
    delete _c_str;
  }
  _c_str_valid = 0;
}; 

// **********************************************************************
void XMLString::deleteData(
			   const unsigned long& offset,
			   const unsigned long& count) {

  unsigned long i = offset + count;
  while(i < _length) {
    _data[i - count] = _data[i];
  }

  if(offset + count > _length) {
    _length = offset;
  }
  else {
    _length -= count;
  }
 
  if(_c_str_valid) {
    delete _c_str;
  }
  _c_str_valid = 0;
}; 

// **********************************************************************
void XMLString::replaceData(
			    const unsigned long& offset,
			    unsigned long count,
			    const XMLString& s) {

  if(offset > _length) {
    *this += s;
  }

  if(offset + count > _length) {
    count = _length - offset;
  }

  unsigned long newLength = _length + s._length - count;
  char* newData = new char[newLength];

  unsigned long i;
  for(i = 0; i < offset; i++) {
    newData[i] = _data[i];
  }

  for(i = offset; i < offset+s._length; i++) {
    newData[i] = s._data[i-offset];
  }

  for(i = offset+s._length; i < newLength; i++) {
    newData[i] = _data[i-s._length+count];
  }

  if(_length) {
    delete _data;
  }
  _data = newData;
  _length = newLength;

  if(_c_str_valid) {
    delete _c_str;
  }
  _c_str_valid = 0;
}; 

// **********************************************************************
void XMLString::subString(
			  XMLString& subS,
			  const unsigned long& begin,
			  const unsigned long& end_plus_one) const {

  if(end_plus_one>_length) {
    throw XMLException(XMLException::RANGE_ERR);
  }

  if(end_plus_one<=begin) {
    subS="";
    return;
  }

  if(subS._length) {
    delete subS._data;
  }
  if(subS._c_str_valid) {
    delete subS._c_str;
  }
  subS._c_str_valid=0;
  subS._data = new char[end_plus_one-begin];
  for(unsigned long i=begin;i<end_plus_one;i++) {
    subS._data[i-begin] = _data[i];
  }
  subS._length = end_plus_one-begin;
}; 

// **********************************************************************
bool XMLString::hasIllegalCharacters() const {
  unsigned long i = 0;
  while(i < _length) {
    if(!XMLChar::isChar(_data[i])) {
      return 1;
    }
    i++;
  }
  return 0;
};

// **********************************************************************
bool XMLString::beginsWithxml() const {
  if(_length < 3) {
    return 0;
  }
  return ((_data[0] == 'x')&(_data[1] == 'm')&(_data[2] == 'l'));
};

// **********************************************************************
bool XMLString::beginsWithXxMmLl() const {
  if(_length < 3) {
    return 0;
  }
  return (((_data[0] == 'X') | (_data[0] == 'x'))
	  &((_data[1] == 'M') | (_data[1] == 'm'))
	  &((_data[2] == 'L') | (_data[2] == 'l')));
};

// **********************************************************************
bool XMLString::eqxml() const {
  if(!(_length==3)) {
    return 0;
  }
  return (((_data[0] == 'X') | (_data[0] == 'x'))
	  &((_data[1] == 'M') | (_data[1] == 'm'))
	  &((_data[2] == 'L') | (_data[2] == 'l')));
};

// **********************************************************************
bool XMLString::eqxmlns() const {
  if(_length != 5) {
    return 0;
  }
  return (((_data[0] == 'x') | (_data[0] == 'X'))
	  &((_data[1] == 'm') | (_data[1] == 'M'))
	  &((_data[2] == 'l') | (_data[2] == 'L'))
	  &((_data[3] == 'n') | (_data[3] == 'N'))
	  &((_data[4] == 's') | (_data[4] == 'S')));
};

// **********************************************************************
bool XMLString::isName() const {
  if (_length == 0) {
      return 0;
  }
  if (!(XMLChar::isLetter(_data[0])|(_data[0]=='_')|(_data[0]==':'))) {
    return 0;
  }
  for(unsigned long i=1;i<_length;i++) {
    if(!XMLChar::isNameChar(_data[i])) {
      return 0;
    }
  }
  return 1;
};

// **********************************************************************
bool XMLString::isNCName() const {
  if (_length == 0) {
      return 0;
  }
  if (!(XMLChar::isLetter(_data[0])|(_data[0]=='_'))) {
    return 0;
  }
  for(unsigned long i=1;i<_length;i++) {
    if(!XMLChar::isNCNameChar(_data[i])) {
	return 0;
    }
  }
  return 1;
};	

// **********************************************************************
bool XMLString::isNSWellFormed() const {
  unsigned long nColons = 0;
  for(unsigned long i=0;i<_length;i++) {
    if(_data[i]==':') {
      nColons++;
    }
  }
  return(nColons < 2);
};

// **********************************************************************
bool XMLString::isVersionNum() const {
  for(unsigned long i=0;i<_length;i++) {
    if(!( XMLChar::isLatinLetter(_data[i])
	  | XMLChar::isLatinDigit(_data[i])
	  |(_data[i]=='_')|(_data[i]=='.')|(_data[i]==':')|(_data[i]=='-'))) {
      return 0;
    }
  }
  return 1;
};

// **********************************************************************
bool XMLString::isEncName() const {
  if (_length==0) {
    return 0;
    }
  if(!( XMLChar::isLatinLetter(_data[0]))) {
    return 0;
  }
  for(unsigned long i=1;i<_length;i++) {
    if(!( XMLChar::isLatinLetter(_data[i])
	  | XMLChar::isLatinDigit(_data[i])
	  |(_data[i]=='_')|(_data[i]=='.')|(_data[i]=='-'))) {
      return 0;
    }
  }
  return 1;
};

// **********************************************************************
bool XMLString::isPubidLiteral() const {
  for(unsigned long i=0;i<_length;i++) {
    if(! XMLChar::isPubidChar(_data[i])) {
      return 0;
    }
  }
  return 1;
};

// **********************************************************************
bool XMLString::splitNSName(
			    XMLString& prefix,
			    XMLString& localPart) const {

  unsigned long firstColon = 0;

  while((firstColon < _length) && (_data[firstColon] != ':')) {
    firstColon++;
  }

  if(firstColon < _length) {
    subString(prefix,0,firstColon);
    subString(localPart,firstColon+1,_length);
    return 1;
  }

  prefix="";
  localPart = *this;

  return 0;
};

// **********************************************************************
bool XMLString::isAllWhiteSpace() const {
  for(unsigned long i=0;i<_length;i++) {
    if(!XMLChar::isWhiteSpace(_data[i])) {
      return 0;
    }
  }
  return 1;
};

// ******************************************************************************
bool XMLString::asULong(
			unsigned long& outULong) const {

  // checks to ensure string contains exactly one parsable
  // positive integer and parses it

  if(_length==0) {
    return 0;
  }

  if(!_c_str_valid) {
    c_str();
  }

  long i=0;

  while(XMLChar::isWhiteSpace(_c_str[i])) {
      // skip white space
    i++;
  }

  while(XMLChar::isLatinDigit(_c_str[i])) {
      // skip numbers
    i++;
  }

  while(XMLChar::isWhiteSpace(_c_str[i])) {
      // skip any more white space
    i++;
  }

  if(_c_str[i] != 0) {
      // should now be at end
    return 0; // more characters!!!
  }

  // finally
  if(sscanf(_c_str,"%lui",&outULong)==1) {
    return 1;
  }

  return 0;
}

// ******************************************************************************
bool XMLString::asDouble(
			 double& outDouble) const {

  // checks to ensure string contains exactly one parsable double and parses it

  if(_length==0) {
    return 0;
  }
 
  if(!_c_str_valid) {
    c_str();
  }

  long i=0;

  while(XMLChar::isWhiteSpace(_c_str[i])) {
      // skip white space
    i++;
  }

  if((_c_str[i]=='+')|(_c_str[i]=='-')) {
      // skip any +/- sign
    i++;
  }

  while(XMLChar::isLatinDigit(_c_str[i])) {
      // skip any numbers
    i++;
  }

  if(_c_str[i]=='.') {
      // skip a decimal point
    i++;
  }

  while(XMLChar::isLatinDigit(_c_str[i])) {
      // skip any more numbers
    i++;
  }

  if((_c_str[i]=='e')|(_c_str[i]=='e'))	{
      // skip exponential
    i++;
    if((_c_str[i]=='+')|(_c_str[i]=='-')) {
	// skip any +/- sign
      i++;
    }
    while(XMLChar::isLatinDigit(_c_str[i])) {
	// skip any more numbers
      i++;
    }
  }

  while(XMLChar::isWhiteSpace(_c_str[i])) {
      // skip any more white space
    i++;
  }

  if(_c_str[i] != 0) {
      // should now be at end
    return 0; // more characters!!!
  }

  // finally
  if(sscanf(_c_str,"%lf",&outDouble)==1) {
    return 1;
  }

  return 0;
}

// **********************************************************************
void XMLString::goLatinAlphaNumeric() {

  if(_length==0) {
    return;
  }

  if(_c_str_valid) {
    delete _c_str;
  }
  _c_str_valid=0;

  if(XMLChar::isLatinDigit(_data[0])) {
    _data[0]='_';
  }

  for(unsigned long i=1; i<_length; i++) {
    if(!(XMLChar::isLatinLetter(_data[i])|XMLChar::isLatinDigit(_data[i])|(_data[i]=='_'))) {
      _data[i]='_';
    }
  }
};