mirror of
https://github.com/RetroShare/RetroShare.git
synced 2025-01-02 03:16:18 -05:00
320 lines
8.2 KiB
C++
320 lines
8.2 KiB
C++
|
|
/*
|
|
* util/contentvalue.cc, key val container
|
|
*
|
|
* Copyright 2012 Christopher Evi-Parker
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License Version 2 as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
|
|
* USA.
|
|
*
|
|
* Please report all bugs and problems to "retroshare@lunamutt.com".
|
|
*
|
|
*/
|
|
|
|
#include <iostream>
|
|
#include <memory.h>
|
|
|
|
#include "contentvalue.h"
|
|
|
|
|
|
|
|
|
|
const uint8_t ContentValue::BOOL_TYPE = 1;
|
|
const uint8_t ContentValue::DATA_TYPE = 2;
|
|
const uint8_t ContentValue::STRING_TYPE = 3;
|
|
const uint8_t ContentValue::DOUBLE_TYPE = 4;
|
|
const uint8_t ContentValue::INT32_TYPE = 5;
|
|
const uint8_t ContentValue::INT64_TYPE = 6;
|
|
|
|
|
|
/**************** content value implementation ******************/
|
|
|
|
typedef std::pair<std::string, uint8_t> KeyTypePair;
|
|
|
|
ContentValue::ContentValue(){
|
|
|
|
}
|
|
|
|
ContentValue::~ContentValue(){
|
|
// release resources held in data
|
|
clearData();
|
|
}
|
|
|
|
ContentValue::ContentValue(const ContentValue &from){
|
|
|
|
std::map<std::string, uint8_t> keyTypeMap;
|
|
from.getKeyTypeMap(keyTypeMap);
|
|
std::map<std::string, uint8_t>::const_iterator cit =
|
|
keyTypeMap.begin();
|
|
|
|
uint8_t type = 0;
|
|
std::string currKey;
|
|
std::string val = "";
|
|
char *src = NULL;
|
|
uint32_t data_len = 0;
|
|
|
|
for(; cit != keyTypeMap.end(); ++cit){
|
|
|
|
type = cit->second;
|
|
currKey = cit->first;
|
|
|
|
switch(type){
|
|
|
|
case INT32_TYPE:
|
|
{
|
|
int32_t value = 0;
|
|
if (from.getAsInt32(currKey, value))
|
|
put(currKey, value);
|
|
break;
|
|
}
|
|
case INT64_TYPE:
|
|
{
|
|
int64_t value = 0;
|
|
if (from.getAsInt64(currKey, value))
|
|
put(currKey, value);
|
|
break;
|
|
}
|
|
case STRING_TYPE:
|
|
{
|
|
if (from.getAsString(currKey, val))
|
|
put(currKey, val);
|
|
break;
|
|
}
|
|
case BOOL_TYPE:
|
|
{
|
|
bool value = false;
|
|
if (from.getAsBool(currKey, value))
|
|
put(currKey, value);
|
|
break;
|
|
}
|
|
case DATA_TYPE:
|
|
{
|
|
if (from.getAsData(currKey, data_len, src))
|
|
put(currKey, data_len, src);
|
|
break;
|
|
}
|
|
case DOUBLE_TYPE:
|
|
{
|
|
double value = 0;
|
|
if (from.getAsDouble(currKey, value))
|
|
put(currKey, value);
|
|
break;
|
|
}
|
|
default:
|
|
std::cerr << "ContentValue::ContentValue(ContentValue &from):"
|
|
<< "Error! Unrecognised data type!" << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, bool value){
|
|
|
|
if(mKvSet.find(key) != mKvSet.end())
|
|
removeKeyValue(key);
|
|
|
|
mKvSet.insert(KeyTypePair(key, BOOL_TYPE));
|
|
mKvBool.insert(std::pair<std::string, bool>(key, value));
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, const std::string &value){
|
|
|
|
if(mKvSet.find(key) != mKvSet.end())
|
|
removeKeyValue(key);
|
|
|
|
mKvSet.insert(KeyTypePair(key, STRING_TYPE));
|
|
mKvString.insert(std::pair<std::string, std::string>(key, value));
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, double value){
|
|
|
|
if(mKvSet.find(key) != mKvSet.end())
|
|
removeKeyValue(key);
|
|
|
|
mKvSet.insert(KeyTypePair(key,DOUBLE_TYPE));
|
|
mKvDouble.insert(std::pair<std::string, double>(key, value));
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, int32_t value){
|
|
|
|
if(mKvSet.find(key) != mKvSet.end())
|
|
removeKeyValue(key);
|
|
|
|
mKvSet.insert(KeyTypePair(key, INT32_TYPE));
|
|
mKvInt32.insert(std::pair<std::string, int32_t>(key, value));
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, int64_t value){
|
|
|
|
if(mKvSet.find(key) != mKvSet.end())
|
|
removeKeyValue(key);
|
|
|
|
mKvSet.insert(KeyTypePair(key, INT64_TYPE));
|
|
mKvInt64.insert(std::pair<std::string, int64_t>(key, value));
|
|
}
|
|
|
|
void ContentValue::put(const std::string &key, uint32_t len, const char* value){
|
|
|
|
|
|
// release memory from old key value if key
|
|
// exists
|
|
if(mKvSet.find(key) != mKvSet.end()) {
|
|
removeKeyValue(key);
|
|
}
|
|
|
|
mKvSet.insert(KeyTypePair(key, DATA_TYPE));
|
|
char* dest = NULL;
|
|
|
|
// len is zero then just put a NULL entry
|
|
if(len != 0){
|
|
dest = new char[len];
|
|
memcpy(dest, value, len);
|
|
}
|
|
|
|
mKvData.insert(std::pair<std::string, std::pair<uint32_t, char*> >
|
|
(key, std::pair<uint32_t, char*>(len, dest)));
|
|
//delete[] dest; //Deleted by clearData()
|
|
}
|
|
|
|
bool ContentValue::getAsBool(const std::string &key, bool& value) const{
|
|
|
|
std::map<std::string, bool>::const_iterator it;
|
|
if((it = mKvBool.find(key)) == mKvBool.end())
|
|
return false;
|
|
|
|
value = it->second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::getAsInt32(const std::string &key, int32_t& value) const{
|
|
|
|
std::map<std::string, int32_t>::const_iterator it;
|
|
if((it = mKvInt32.find(key)) == mKvInt32.end())
|
|
return false;
|
|
|
|
value = it->second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::getAsInt64(const std::string &key, int64_t& value) const{
|
|
|
|
std::map<std::string, int64_t>::const_iterator it;
|
|
if((it = mKvInt64.find(key)) == mKvInt64.end())
|
|
return false;
|
|
|
|
value = it->second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::getAsString(const std::string &key, std::string &value) const{
|
|
|
|
std::map<std::string, std::string>::const_iterator it;
|
|
if((it = mKvString.find(key)) == mKvString.end())
|
|
return false;
|
|
|
|
value = it->second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::getAsData(const std::string& key, uint32_t &len, char*& value) const{
|
|
|
|
std::map<std::string, std::pair<uint32_t, char*> >::const_iterator it;
|
|
if((it = mKvData.find(key)) == mKvData.end())
|
|
return false;
|
|
|
|
const std::pair<uint32_t, char*> &kvRef = it->second;
|
|
|
|
len = kvRef.first;
|
|
value = kvRef.second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::getAsDouble(const std::string &key, double& value) const{
|
|
|
|
std::map<std::string, double>::const_iterator it;
|
|
if((it = mKvDouble.find(key)) == mKvDouble.end())
|
|
return false;
|
|
|
|
value = it->second;
|
|
return true;
|
|
}
|
|
|
|
bool ContentValue::removeKeyValue(const std::string &key){
|
|
|
|
std::map<std::string, uint8_t>::iterator mit;
|
|
|
|
if((mit = mKvSet.find(key)) == mKvSet.end())
|
|
return false;
|
|
|
|
if(mit->second == BOOL_TYPE)
|
|
mKvBool.erase(key);
|
|
|
|
if(mit->second == INT64_TYPE)
|
|
mKvInt64.erase(key);
|
|
|
|
if(mit->second == DATA_TYPE){
|
|
delete[] (mKvData[key].second);
|
|
mKvData.erase(key);
|
|
}
|
|
|
|
if(mit->second == DOUBLE_TYPE)
|
|
mKvDouble.erase(key);
|
|
|
|
if(mit->second == STRING_TYPE)
|
|
mKvString.erase(key);
|
|
|
|
if(mit->second == INT32_TYPE)
|
|
mKvInt32.erase(key);
|
|
|
|
|
|
mKvSet.erase(key);
|
|
return true;
|
|
}
|
|
|
|
|
|
void ContentValue::getKeyTypeMap(std::map<std::string, uint8_t> &keySet) const {
|
|
keySet = mKvSet;
|
|
}
|
|
|
|
void ContentValue::clear(){
|
|
mKvSet.clear();
|
|
mKvBool.clear();
|
|
mKvDouble.clear();
|
|
mKvString.clear();
|
|
mKvInt32.clear();
|
|
mKvInt64.clear();
|
|
clearData();
|
|
}
|
|
|
|
bool ContentValue::empty() const{
|
|
return mKvSet.empty();
|
|
}
|
|
|
|
void ContentValue::clearData(){
|
|
|
|
std::map<std::string, std::pair<uint32_t, char*> >::iterator
|
|
mit = mKvData.begin();
|
|
|
|
for(; mit != mKvData.end(); ++mit){
|
|
|
|
if(mit->second.first != 0)
|
|
delete[] (mit->second.second);
|
|
}
|
|
|
|
mKvData.clear();
|
|
}
|
|
|
|
|
|
|