Search  

---

C:/temp/src/j2k/Fred/String/StrNew.cpp

Go to the documentation of this file.

#ifndef __J2K__JString_New_CPP__
#define __J2K__JString_New_CPP__

#include <j2k/Fred/String/String.hpp>

// New features from Odin Plus Plus 0.2 library
// LGPL licensed too.

ULONG JString::hash(const char* buf, ULONG len) {
  ULONG h = 129871;  // "randomly" chosen
  ULONG skip;
  ULONG i = len;

  if (len<16) {
    for (i = len; i; --i, ++buf) {
      h = (h + *buf    ) * 16647143;
    }
  } else {
    skip=len/8;
    for( i=0;i<len;i+=skip,buf+=skip ) {
      h = (h + *buf     ) * 16647143;
      h = (h + *(buf+1) ) * 16647143;
/** ANDREA ***************************************************

  This code may access buf[len], in other words the (len+1)-th
  byte. I hope this is understood by callers. To see why
  consider a string of lenght 17.

  It's not my code... =)

*************************************************************/
    }
  }
  return h;
}

char* JString::dup() const {
  char *buf=new char[contents.getMagic()->len+1];
  memcpy(buf,contents.getMagic()->buf,contents.getMagic()->len+1);
  return buf;
}

void JString::copyTo(void* dest, ULONG offset, ULONG len) const {
  ULONG mylen=length();
  if (offset<mylen) {
    if ( offset+len > mylen ) {
      throw IndexOutOfBoundsException(offset+len);
    }
    memcpy(dest,getBytes(),len);
  }
  //else throw IndexOutOfBoundsException(offset);

/** ANDREA ***************************************************

  Seeing a throw I may suspect that your library should be
  used in an environment that supports exceptions.
  Unfortunately most of your code is really really far from
  being exception safe.

  It's not my code... =)

*************************************************************/

}

ULONG JString::subJStringByLength(void* dest, ULONG offset, ULONG len) const
{
  ULONG mylen = length();
  if (offset<mylen) {
    if (offset+len>mylen) len=mylen-offset;
    memcpy(dest,getBytes(),len);
    return len;
  }
  return 0;
}

JString JString::subJString( ULONG start, ULONG end) const {
  ImmutableJString *c=contents.getMagic();
  if (start>=c->len||end<=start) {
    return JString();
  }
  if (end>c->len) end=c->len;
  return JString(&(c->buf[start]),end-start);
}

BOOL JString::startsWith(const char* s, ULONG off, ULONG len) const {
  ULONG mylen = length();
  const char *buf = getBytes();
  ULONG i;
  for( i = 0; i < len&&off < mylen; ++i ) {
    if ( s[i] != buf[off]) break;
    ++off;
  }
/** ANDREA ***************************************************

  This is a good idea. Removing all spaces can make your
  code running faster...  (joke ;) )

  Why not using strncmp() ?

*************************************************************/
  return (i==len);
}
 
BOOL JString::startsWith(const char s, ULONG off) const {
  ULONG mylen=length();
  const char* buf=getBytes();
  if (off<mylen) return buf[off]==s;
  return FALSE;
}

BOOL JString::endsWith(const char* s, ULONG len) const {
  ULONG mylen=length();
  const char* buf=getBytes();
  ULONG i;
  if (mylen<len) return FALSE;
  ULONG off=mylen-len;

  for (i=0;i<len&&off<mylen;++i) {
    if (s[i]!=buf[off]) break;
    off++;
  }
  return (i==len);
}

/* NOTE: this originally used memmem(),
 * which is apparently broken under Linux...
 */

/** ANDREA ***************************************************

Really hard to believe but I'll check. What gcc and libraries
version ?

  It's not my code... =)

*************************************************************/

#define MODULO 16647143

int JString::indexOf(const char* buf, ULONG mylen, const char* s, ULONG len, ULONG off)
{
  if (off+len>mylen)
    return -1;

  ULONG match = 0;
  ULONG hash  = 0;
  ULONG mask  = 1;
  ULONG i;

  for( i = 0; i < len; i++ ) {
    hash = (128*hash+s[i])%MODULO;
    if (i) mask=(128*mask)%MODULO;
  }

  i=0;
  while (off<mylen) {
    if (i<len) {
      match=(128*match+buf[off])%MODULO;

    } else {
      if (match==hash) {
        /* possible match on previous length characters* /
        if (memcmp(&buf[off-len],s,len)==0) {
          return off-len;
        }
      }

      match = (match+128*MODULO-mask*buf[off-len])%MODULO;
      match = (match*128+buf[off])%MODULO;
    }

  ++off;
  ++i;
  }
  return -1;
}

int JString::lastIndexOf(char c, ULONG off) const {
  ULONG len = length();
  const char* buf = getBytes();

  if (off>=len)
    return -1;

  while (1) {
    if (buf[off]==c)
      return off;
   
    if (off) {
      off--;
    } else {
      break;
    }
  }
  return -1;
}

int JString::toInteger( ULONG off) const {
  if (off<=length()) {
    return atoi(&(contents.getMagic()->buf)[off]);
  }
  // throw IndexOutOfBoundsException(off);
}

ULONG JString::toUnsignedInteger(ULONG off) const {
  if (off<=length()) {
    return strtoul(&(contents.getMagic()->buf)[off],0,0);
  }
  // throw IndexOutOfBoundsException(off);
}

double JString::toDouble(ULONG off) const {
  if (off<=length()) {
    return atof(&(contents.getMagic()->buf)[off]);
  }
 // throw IndexOutOfBoundsException(off);
}

char JString::operator[] (ULONG offset) const {
  if (offset<=length()) {
    return contents.getMagic()->buf[offset];
  }
  // throw IndexOutOfBoundsException(offset);
}

JObject* JString::Copy() const {
  return new JString(*this);
}

/** ANDREA ***************************************************

  Hey... this is a different thing.
  Gosh... my reading stops here.

*************************************************************/

ULONG JString::hash() const {
  return hash(contents.getMagic()->buf,contents.getMagic()->len);
}

BOOL JString::Equals(const JObject &o) const {
  const JString* other=dynamic_cast<const JString* >(&o);
  if (other) {
    return ::operator==(*this,*other);
  } else {
    const JStringBuffer* other2=dynamic_cast<const JStringBuffer* >(&o);
    if (other2) return ::operator==(*this,*other2);
  }
  return FALSE;
}

BOOL JString::lessThan(const Object &o) const {
  const JString* other=dynamic_cast<const JString* >(&o);
  if (other) {
    return ::operator<(*this,*other);
  } else {
    const JStringBuffer* other2=dynamic_cast<const JStringBuffer* >(&o);
    if (other2) return ::operator<(*this,*other2);
  }
  return FALSE;
}

BOOL JString::lessThanEquals(const JObject &o) const {
  const JString* other=dynamic_cast<const JString* >(&o);
  if (other) {
    return ::operator<=(*this,*other);
  } else {
    const JStringBuffer* other2=dynamic_cast<const JStringBuffer* >(&o);
    if (other2) return ::operator<=(*this,*other2);
  }
  return FALSE;
}

void JStringBuffer::setLength( ULONG newLength)  {
  if (newLength>magic->len) {
    ensureCapacity(newLength-magic->len);
  }
  magic->len=newLength;
  if (magic->buf) magic->buf[newLength]=0;
}

void JStringBuffer::ensureCapacity( ULONG extra) {
  MutableJString* mut=magic.getMagic();
  if (mut->len+extra>=mut->maxlen) {
    mut->reallocate(mut->len+extra);
  }
}

char* JStringBuffer::dup() const {
  char* buf=new char[magic->len+1];
  memcpy(buf,magic->buf,magic->len+1);
  return buf;
}

void JStringBuffer::copyTo(void* dest, ULONG offset, ULONG len) const {
  ULONG mylen=length();
  if (offset<mylen) {
    if (offset+len>mylen) {
     // throw IndexOutOfBoundsException(offset+len);
    }
    memcpy(dest,&getBytes()[offset],len);
  } else {
     // throw IndexOutOfBoundsException(offset);
  }
}

ULONG JStringBuffer::subJStringByLength(void* dest, ULONG offset, ULONG len) const
{
  ULONG mylen=length();
  if (offset<mylen) {
    if (offset+len>mylen)
      len=mylen-offset;

    memcpy(dest,getBytes(),len);
    return len;
  }
  return 0;
}

JStringBuffer JStringBuffer::subJString(ULONG start,ULONG end) const {
  MutableJString* c=magic.getMagic();
  if (start>=c->len||end<=start) {
    return JStringBuffer();
  }

  if (end > c->len) {
    end = c->len;
  }

  return JStringBuffer(&(c->buf[start]),end-start);
}

BOOL JStringBuffer::startsWith(const char* s,ULONG off,ULONG len) const
{
    ULONG mylen=length();
    const char* buf=getBytes();
    ULONG i;
    for (i=0;i<len&&off<mylen;++i) {
      if (s[i]!=buf[off]) break;
      ++off;
    }
    return (i==len);
}

BOOL JStringBuffer::startsWith(const char s,ULONG off) const {
  ULONG mylen=length();
  const char* buf=getBytes();
  if (off<mylen)
    return buf[off]==s;

  return FALSE;
}

BOOL JStringBuffer::endsWith(const char* s,ULONG len) const {
  ULONG mylen=length();
  const char* buf=getBytes();
  ULONG i;
  if (mylen<len) return FALSE;
  ULONG off=mylen-len;

  for (i=0;i<len&&off<mylen;++i) {
    if (s[i]!=buf[off]) break;
    ++off;
  }
  return (i==len);
}

int JStringBuffer::indexOf(char c,ULONG off) const {
  ULONG len=length();
  const char* buf=getBytes();
  while (off<len) {
    if (buf[off]==c) return off;
    off++;
  }
  return -1;
}

int JStringBuffer::lastIndexOf(char c,ULONG off) const {
  ULONG len=length();
  const char* buf=getBytes();
  if (off>=len) return -1;
  while (1) {
    if (buf[off]==c) return off;
    if (off) {
      off--;
    } else {
      break;
    }
  }
  return -1;
}

char& JStringBuffer::operator[] (ULONG offset) {
  if (magic->buf&&offset<=magic->len) {
    return magic->buf[offset];
  } else if (offset==0) {
    magic=new MutableJString(16);
    return magic->buf[0];
  }

 // throw IndexOutOfBoundsException(offset);
}

char JStringBuffer::operator[] (ULONG offset) const {
  if (magic->buf&&offset<=magic->len) {
    return magic->buf[offset];
  } else if (offset==0) return 0;

//    throw IndexOutOfBoundsException(offset);
}

Object* JStringBuffer::Copy() const {
  JStringBuffer* ret=new JStringBuffer;
  *ret=*this;
  return ret;
}

void JStringBuffer::Serialize(Serializer &out) const {
  out.pushBytes(*this);
}

void JStringBuffer::Deserialize(Deserializer &in) {
  in.popBytes(*this);
}

ULONG JStringBuffer::hash() const {
  return JString::hash(magic->buf,magic->len);
}

JString JStringBuffer::toJString() const {
  return JString(*this);
}

BOOL JStringBuffer::Equals(const Object &o) const {
  const JStringBuffer* other=dynamic_cast<const JStringBuffer* >(&o);
  if (other) {
    return ::operator==(*this,*other);
  } else {
    const JString* other2=dynamic_cast<const JString* >(&o);
  if (other2) return ::operator==(*this,*other2);
  }
  return FALSE;
}

BOOL JStringBuffer::lessThan(const Object &o) const {
  const JStringBuffer* other=dynamic_cast<const JStringBuffer* >(&o);
  if (other) {
    return ::operator<(*this,*other);
  } else {
    const JString* other2=dynamic_cast<const JString* >(&o);
  if (other2) return ::operator<(*this,*other2);
  }
  return FALSE;
}

BOOL JStringBuffer::lessThanEquals(const Object &o) const {
  const JStringBuffer* other=dynamic_cast<const JStringBuffer* >(&o);
  if (other) {
    return ::operator<=(*this,*other);
  } else {
    const JString* other2=dynamic_cast<const JString* >(&o);
    if (other2) return ::operator<=(*this,*other2);
  }
  return FALSE;
}

int JStringBuffer::toInteger(ULONG off) const {
  if (off<=length()) {
    return atoi(&(magic->buf)[off]);
  }
  //  throw IndexOutOfBoundsException(off);
}

ULONG JStringBuffer::toUnsignedInteger(ULONG off) const {
  if (off<=length()) {
    return strtoul(&(magic->buf)[off],0,0);
  }
  //  throw IndexOutOfBoundsException(off);
}

double JStringBuffer::toDouble(ULONG off) const {
  if (off<=length()) {
    return atof(&(magic->buf)[off]);
  }
  //  throw IndexOutOfBoundsException(off);
}

JStringBuffer::IndexOutOfBoundsException::IndexOutOfBoundsException(int idx) {
  char* buf=new char[512];
  sprintf(buf,"JStringBuffer index %d out of bounds",idx);
  Exception::setMessage(buf,1);
}

void JStringBuffer::MutableJString::reallocate(ULONG min) {
  if (min<len) min=len;
  if (min==0) {
    if (buf) delete [] buf;
    buf=new char[16];
    buf[0]=0;
    maxlen=16;
    len=0;
    return;
  }
  maxlen=(ULONG)((min+16)*1.2);
  //assert(maxlen>=len);
  char* newbuf=new char[maxlen];
  if (buf) {
    memcpy(newbuf,buf,len);
    delete [] buf;
  }
  newbuf[len]=0;
  buf=newbuf;
}

JStringBuffer::MutableJString::MutableJString(const char* ibuf,ULONG len) : len(len), buf(0) {
  reallocate(len+1);
  memcpy(buf,ibuf,len);
}

JStringBuffer::MutableJString::MutableJString(const MutableJString &other) : len(other.len), buf(0) {
  reallocate(other.len+1);
  memcpy(buf,other.buf,len);
}

JStringBuffer::MutableJString::MutableJString(ULONG max) : len(0), buf(0) {
  reallocate(max);
}

JStringBuffer::MutableJString::MutableJString() : len(0), maxlen(0), buf(0) {
  reallocate(maxlen);
}

void JStringBuffer::MutableJString::append(const char* ap,ULONG amount) {
  if (ap&&amount) {
    if (len+amount+1>maxlen) {
      reallocate(len+amount+1);
    }
    memcpy(&buf[len],ap,amount);
    len+=amount;
    buf[len]=0;
  }
}
void JStringBuffer::translate(char from,char to) {
  MutableJString* c=magic.getMagic();
  char* buf=c->buf;
  ULONG len=c->len;
  while (len) {
    --len;
    if (*buf==from)* buf=to;
    ++buf;
  }
}

void JStringBuffer::translate(const char* from,const char* to) {
  MutableJString* c=magic.getMagic();
  char* buf=c->buf;
  ULONG len=c->len;
  char* p;
  while (len) {
    --len;
    if ((p=strchr(from,*buf))) {
       *buf=to[p-from];
    }
    ++buf;
  }
}

void JStringBuffer::remove(const char* from) {
  MutableJString* c=magic.getMagic();
  char* buf=c->buf;
  ULONG len=c->len;
  ULONG nlen=0;
  char* q;
  q=buf;
  while (len) {
  --len;
    if (!strchr(from,*buf)) {
      if (buf!=q)* q=*buf;
      ++q;
      ++nlen;
  }
  ++buf;
  }
  setLength(nlen);
}

JStringBuffer& JStringBuffer::chop(const char* str) {
  ULONG len=length();
  const char* buf=getBytes();
  while (len) {
  --len;
  if (!strchr(str,buf[len])) {
      setLength(len+1);
      return* this;
    }
  }
  setLength(0);
  return *this;
}

JStringBuffer& JStringBuffer::operator<< (int i) {
  char str[20];
  int len=sprintf(str,"%d",i);
  append(str,len);
  return *this;
}
JStringBuffer& JStringBuffer::chop(ULONG n) {
  ULONG len=length();
  if (len>n) {
    setLength(len-n);
  } else {
    setLength(0);
  }
  return *this;
}

JStringBuffer& JStringBuffer::chop(char ch) {
  ULONG len=length();
  const char* buf=getBytes();
  while (len) {
  --len;
    if (buf[len]!=ch) {
      setLength(len+1);
      return *this;
    }
  }
  setLength(0);
  return *this;
}

#endif

---