You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
327 lines
7.6 KiB
327 lines
7.6 KiB
/***************************************************************************
|
|
KEMessage.cpp - description
|
|
-------------------
|
|
begin : Tue May 2 2000
|
|
copyright : (C) 2000 by Martin Heni
|
|
email : martin@heni-online.de
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include "KEMessage.h"
|
|
|
|
void KEMessage::AddEntry(TQString key,KMessageEntry *entry)
|
|
{
|
|
// printf(" AddingEntry: %s with data field %p\n",(char *)key,entry->QueryData());
|
|
if (!entry) return ;
|
|
dict.insert(key,entry);
|
|
keys.append(key.latin1());
|
|
}
|
|
|
|
void KEMessage::AddDataType(TQString key,int size,const char *data,KGM_TYPE type)
|
|
{
|
|
// printf("AddDataType for %s size=%d\n",(const char *)key,size);
|
|
if (size<=0) return ;
|
|
KMessageEntry *entry=new KMessageEntry;
|
|
entry->SetType(type);
|
|
entry->CopyData(size,data);
|
|
AddEntry(key,entry);
|
|
}
|
|
|
|
void KEMessage::AddData(TQString key,short data)
|
|
{
|
|
AddDataType(key,sizeof(short),(char *)&data,KGM_TYPE_SHORT);
|
|
}
|
|
|
|
void KEMessage::AddData(TQString key,long data)
|
|
{
|
|
AddDataType(key,sizeof(long),(char *)&data,KGM_TYPE_LONG);
|
|
}
|
|
|
|
void KEMessage::AddData(TQString key,float data)
|
|
{
|
|
AddDataType(key,sizeof(float),(char *)&data,KGM_TYPE_FLOAT);
|
|
}
|
|
|
|
void KEMessage::AddData(TQString key,const char *data,int size)
|
|
{
|
|
if (size<0) size=strlen(data)+1; // +1 for 0 Byte
|
|
AddDataType(key,size,data,KGM_TYPE_DATA);
|
|
}
|
|
|
|
KGM_TYPE KEMessage::QueryType(TQString key)
|
|
{
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return (KGM_TYPE)0;
|
|
return entry->QueryType();
|
|
}
|
|
|
|
bool KEMessage::HasKey(TQString key)
|
|
{
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return false;
|
|
return true;
|
|
}
|
|
|
|
bool KEMessage::GetData(TQString key,short &s)
|
|
{
|
|
short *result;
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return false;
|
|
if (entry->QueryType()!=KGM_TYPE_SHORT) return false;
|
|
// printf("GetShortData: %p for %s\n",entry->QueryData(),(char *)key);
|
|
result=(short *)entry->QueryData();
|
|
s=*result;
|
|
return true;
|
|
}
|
|
|
|
bool KEMessage::GetData(TQString key,long &l)
|
|
{
|
|
long *result;
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return false;
|
|
if (entry->QueryType()!=KGM_TYPE_LONG) return false;
|
|
result=(long *)entry->QueryData();
|
|
l=*result;
|
|
return true;
|
|
}
|
|
|
|
bool KEMessage::GetData(TQString key,float &f)
|
|
{
|
|
float *result;
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return false;
|
|
if (entry->QueryType()!=KGM_TYPE_FLOAT) return false;
|
|
// printf("GetFloatData: %p for %s\n",entry->QueryData(),(char *)key);
|
|
result=(float *)entry->QueryData();
|
|
f=*result;
|
|
return true;
|
|
}
|
|
|
|
bool KEMessage::GetData(TQString key,char * &c,int &size)
|
|
{
|
|
KMessageEntry *entry;
|
|
entry=dict.find(key);
|
|
if (!entry) return false;
|
|
if (entry->QueryType()!=KGM_TYPE_DATA) return false;
|
|
c=entry->QueryData();
|
|
size=entry->QuerySize();
|
|
return true;
|
|
}
|
|
|
|
TQString KEMessage::EntryToString(char *key,KMessageEntry *entry)
|
|
{
|
|
TQString s,tmp;
|
|
int size,i;
|
|
KGM_TYPE type;
|
|
char *data;
|
|
s=TQCString("");
|
|
if (!entry) return s;
|
|
size=entry->QuerySize();
|
|
type=entry->QueryType();
|
|
data=entry->QueryData();
|
|
|
|
// Key
|
|
/*
|
|
tmp.sprintf("%s%s%d%s%d%s",
|
|
key,KEMESSAGE_SEP,
|
|
size,KEMESSAGE_SEP,
|
|
(int)type,KEMESSAGE_SEP);
|
|
*/
|
|
tmp=TQCString(key);
|
|
s+=tmp;
|
|
s+=KEMESSAGE_SEP;
|
|
tmp.sprintf("%d",size);
|
|
s+=tmp;
|
|
s+=KEMESSAGE_SEP;
|
|
tmp.sprintf("%d",(int)type);
|
|
s+=tmp;
|
|
s+=KEMESSAGE_SEP;
|
|
|
|
|
|
// We ignore the type of data and process them all as
|
|
// byte sequence
|
|
for (i=0;i<size;i++)
|
|
{
|
|
// Convert to 4 bit value ... someone can improves
|
|
tmp.sprintf("%c%c",
|
|
'a'+(data[i]&15),
|
|
'a'+((data[i]>>4)&15));
|
|
s+=tmp;
|
|
}
|
|
s+=KEMESSAGE_CR;
|
|
|
|
return s;
|
|
}
|
|
|
|
TQString KEMessage::StringToEntry(TQString str,KMessageEntry *entry)
|
|
{
|
|
int pos,oldpos,cnt,len;
|
|
TQString key,size,type,data;
|
|
const char *p;
|
|
char *q;
|
|
char c;
|
|
|
|
len=KEMESSAGE_SEP.length();
|
|
|
|
if (!entry) return TQString();
|
|
pos=str.find(KEMESSAGE_SEP,0);
|
|
if (pos<0) return TQString(); // wrong format
|
|
key=str.left(pos);
|
|
|
|
|
|
oldpos=pos;
|
|
pos=str.find(KEMESSAGE_SEP,oldpos+len);
|
|
if (pos<0) return TQString(); // wrong format
|
|
size=str.mid(oldpos+len,pos-oldpos-len);
|
|
|
|
|
|
oldpos=pos;
|
|
pos=str.find(KEMESSAGE_SEP,oldpos+len);
|
|
if (pos<0) return TQString(); // wrong format
|
|
type=str.mid(oldpos+len,pos-oldpos-len);
|
|
|
|
|
|
data=str.right(str.length()-pos-len);
|
|
|
|
|
|
cnt=size.toInt();
|
|
entry->SetType((KGM_TYPE)type.toInt());
|
|
|
|
// I hope this works with unicode strings as well
|
|
p=data.latin1();
|
|
q=(char *)calloc(data.length()/2,sizeof(char));
|
|
if (!q) return TQString();
|
|
for(pos=0;pos<cnt;pos++)
|
|
{
|
|
if (pos*2+1>(int)data.length()) return TQString(); // SEVERE ERROR
|
|
c=*(p+2*pos)-'a' | ((*(p+2*pos+1)-'a')<<4);
|
|
q[pos]=c;
|
|
}
|
|
entry->CopyData(cnt,q);
|
|
|
|
free(q);
|
|
return key;
|
|
}
|
|
|
|
TQString KEMessage::ToString()
|
|
{
|
|
TQString s;
|
|
KMessageEntry *entry;
|
|
char *it;
|
|
s=KEMESSAGE_HEAD+KEMESSAGE_CR;
|
|
for (it=keys.first();it!=0;it=keys.next())
|
|
{
|
|
entry=dict.find(TQCString(it));
|
|
s+=EntryToString(it,entry);
|
|
}
|
|
s+=KEMESSAGE_TAIL+KEMESSAGE_CR;
|
|
return s;
|
|
}
|
|
|
|
bool KEMessage::AddString(TQString s)
|
|
{
|
|
// break s into key,size and data
|
|
TQString key;
|
|
KMessageEntry *entry=new KMessageEntry;
|
|
key=StringToEntry(s,entry);
|
|
if (!key) return false;
|
|
AddEntry(key,entry);
|
|
return true;
|
|
}
|
|
bool KEMessage::AddStringMsg(TQString str)
|
|
{
|
|
bool result;
|
|
TQString data;
|
|
int pos,oldpos,len;
|
|
|
|
len=KEMESSAGE_CR.length();
|
|
|
|
pos=str.find(KEMESSAGE_CR);
|
|
if (pos<0) return false; // wrong format
|
|
if (str.left(pos)!=(KEMESSAGE_HEAD)) return false; // wrong message
|
|
|
|
do
|
|
{
|
|
oldpos=pos;
|
|
pos=str.find(KEMESSAGE_CR,oldpos+len);
|
|
if (pos<0) return false; // wrong format
|
|
data=str.mid(oldpos+len,pos-oldpos-len);
|
|
if (data!=(KEMESSAGE_TAIL))
|
|
{
|
|
result=AddString(data);
|
|
if (!result) return false; // wrong format
|
|
}
|
|
}while(data!=(KEMESSAGE_TAIL));
|
|
|
|
return result;
|
|
}
|
|
|
|
void KEMessage::RemoveAll()
|
|
{
|
|
keys.clear();
|
|
dict.clear();
|
|
}
|
|
|
|
void KEMessage::Remove(TQString key)
|
|
{
|
|
keys.remove(key.latin1());
|
|
dict.remove(key);
|
|
}
|
|
|
|
uint KEMessage::QueryNumberOfKeys()
|
|
{
|
|
return keys.count();
|
|
}
|
|
TQStrList *KEMessage::QueryKeys()
|
|
{
|
|
return &keys;
|
|
}
|
|
|
|
KEMessage::~KEMessage()
|
|
{
|
|
// printf("Deleteing KEMessage %p\n",this);
|
|
}
|
|
KEMessage::KEMessage()
|
|
{
|
|
// printf("KEMessage construct %p\n",this);
|
|
dict.setAutoDelete(true);
|
|
}
|
|
KEMessage::KEMessage(KEMessage &msg)
|
|
{
|
|
// printf("KEMessage copy constructor from %p to %p\n",&msg,this);
|
|
*this=msg;
|
|
}
|
|
KEMessage &KEMessage::operator=(KEMessage &msg)
|
|
{
|
|
// KEMessage *newmsg=new KEMessage;
|
|
KMessageEntry *entry;
|
|
KMessageEntry *newentry;
|
|
char *it;
|
|
// printf("Assigning = KEMessage from %p to %p\n",&msg,this);
|
|
for (it=msg.keys.first();it!=0;it=msg.keys.next())
|
|
{
|
|
entry=msg.dict.find(TQCString(it));
|
|
newentry=new KMessageEntry;
|
|
*newentry=*entry;
|
|
AddEntry(TQCString(it),newentry);
|
|
|
|
}
|
|
// return *newmsg;
|
|
return *this;
|
|
}
|