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.
tdegames/lskat/lskat/KEMessage.cpp

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 tqunicode 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;
}