WebSVN – HomeAutomation – Diff – /trunk/PcSoftware/Atom1.5/src/common/Byteset.cpp


/*
 *
 *  Copyright (C) 2010  Mattias Runge
 *
 *  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.
 *
 *  This program 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 */
 
#include "Byteset.h"
 
#include "string.h"
 
#include <boost/lexical_cast.hpp>
 
namespace atom {
namespace common {
 
Byteset::Byteset(unsigned int max_size)
{
    this->max_size_ = max_size;
    this->bytes_ = new unsigned char[this->max_size_];
   
    this->Clear();
}
 
Byteset::Byteset(const Byteset& set)
{
    this->max_size_ = set.size_;
    this->size_ = this->max_size_;
    this->bytes_ = new unsigned char[this->max_size_];
 
    memcpy(this->bytes_, set.bytes_, this->max_size_);
}
 
Byteset::Byteset(std::string str)
{
    this->max_size_ = str.size() + 1;
    this->size_ = this->max_size_;
    this->bytes_ = new unsigned char[this->max_size_];
   
    memcpy(this->bytes_, str.data(), this->max_size_);
}
 
Byteset::Byteset(std::string str, bool no_null_termination)
{
    this->max_size_ = str.size() + (no_null_termination ? 0 : 1);
    this->size_ = this->max_size_;
    this->bytes_ = new unsigned char[this->max_size_];
   
    memcpy(this->bytes_, str.data(), this->max_size_);
}
 
Byteset::~Byteset()
{
    delete [] this->bytes_;
}
 
unsigned char* Byteset::Get() const
{
    return this->bytes_;
}
 
std::string Byteset::ToCharString()
{
    return std::string((char*)this->bytes_, this->size_);
}
 
std::string Byteset::ToDebugString()
{
    std::string debug_string;
   
    for (unsigned int n = 0; n < this->size_; n++)
    {
        debug_string += boost::lexical_cast<std::string>((unsigned int)this->bytes_[n]) + ",";
    }
   
    return debug_string;
}
 
unsigned char& Byteset::operator[](unsigned int index)
{
    if (this->size_ < index + 1)
    {
        this->size_ = index + 1;
    }
   
    return this->bytes_[index];
}
 
unsigned int Byteset::GetMaxSize() const
{
    return this->max_size_;
}
 
unsigned int Byteset::GetSize() const
{
    return this->size_;
}
 
void Byteset::SetSize(unsigned int size)
{
    this->size_ = size;
}
 
void Byteset::Append(unsigned char byte)
{
    this->bytes_[this->size_] = byte;
    this->size_++;
}
 
void Byteset::Clear()
{
    memset(this->bytes_, 0, this->max_size_);
    this->size_ = 0;
}
 
void Byteset::Fill(char c)
{
    memset(this->bytes_, c, this->max_size_);
    this->size_ = 0;
}
   
}; // namespace type
}; // namespace atom
 

Subversion Repositories HomeAutomation

(root)/trunk/PcSoftware/Atom1.5/src/common/Byteset.cpp – Rev 1916 → 1952

Rev 1916		Rev 1952
1	/*	1	/*
2	*	2	*
3	* Copyright (C) 2010 Mattias Runge	3	* Copyright (C) 2010 Mattias Runge
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.	13	* GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License along	15	* You should have received a copy of the GNU General Public License along
16	* with this program; if not, write to the Free Software Foundation, Inc.,	16	* with this program; if not, write to the Free Software Foundation, Inc.,
17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.	17	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18	*	18	*
19	*/	19	*/
20		20
21	#include "Byteset.h"	21	#include "Byteset.h"
22		22
23	#include "string.h"	23	#include "string.h"
24		24
25	#include <boost/lexical_cast.hpp>	25	#include <boost/lexical_cast.hpp>
26		26
27	namespace atom {	27	namespace atom {
28	namespace common {	28	namespace common {
29		29
30	Byteset::Byteset(unsigned int max_size)	30	Byteset::Byteset(unsigned int max_size)
31	{	31	{
32	this->max_size_ = max_size;	32	this->max_size_ = max_size;
33	this->bytes_ = new unsigned char[this->max_size_];	33	this->bytes_ = new unsigned char[this->max_size_];
34		34
35	this->Clear();	35	this->Clear();
36	}	36	}
37		37
38	Byteset::Byteset(const Byteset& set)	38	Byteset::Byteset(const Byteset& set)
39	{	39	{
40	this->max_size_ = set.size_;	40	this->max_size_ = set.size_;
41	this->size_ = this->max_size_;	41	this->size_ = this->max_size_;
42	this->bytes_ = new unsigned char[this->max_size_];	42	this->bytes_ = new unsigned char[this->max_size_];
43		43
44	memcpy(this->bytes_, set.bytes_, this->max_size_);	44	memcpy(this->bytes_, set.bytes_, this->max_size_);
45	}	45	}
46		46
47	Byteset::Byteset(std::string str)	47	Byteset::Byteset(std::string str)
48	{	48	{
49	this->max_size_ = str.size() + 1;	49	this->max_size_ = str.size() + 1;
50	this->size_ = this->max_size_;	50	this->size_ = this->max_size_;
51	this->bytes_ = new unsigned char[this->max_size_];	51	this->bytes_ = new unsigned char[this->max_size_];
52		52
53	memcpy(this->bytes_, str.data(), this->max_size_);	53	memcpy(this->bytes_, str.data(), this->max_size_);
54	}	54	}
55		55
56	Byteset::Byteset(std::string str, bool no_null_termination)	56	Byteset::Byteset(std::string str, bool no_null_termination)
57	{	57	{
58	this->max_size_ = str.size() + (no_null_termination ? 0 : 1);	58	this->max_size_ = str.size() + (no_null_termination ? 0 : 1);
59	this->size_ = this->max_size_;	59	this->size_ = this->max_size_;
60	this->bytes_ = new unsigned char[this->max_size_];	60	this->bytes_ = new unsigned char[this->max_size_];
61		61
62	memcpy(this->bytes_, str.data(), this->max_size_);	62	memcpy(this->bytes_, str.data(), this->max_size_);
63	}	63	}
64		64
65	Byteset::~Byteset()	65	Byteset::~Byteset()
66	{	66	{
67	delete [] this->bytes_;	67	delete [] this->bytes_;
68	}	68	}
69		69
70	unsigned char* Byteset::Get() const	70	unsigned char* Byteset::Get() const
71	{	71	{
72	return this->bytes_;	72	return this->bytes_;
73	}	73	}
74		74
75	std::string Byteset::ToCharString()	75	std::string Byteset::ToCharString()
76	{	76	{
77	return std::string((char*)this->bytes_, this->size_ ~~- 1~~);	77	return std::string((char*)this->bytes_, this->size_);
78	}	78	}
79		79
80	std::string Byteset::ToDebugString()	80	std::string Byteset::ToDebugString()
81	{	81	{
82	std::string debug_string;	82	std::string debug_string;
83		83
84	for (unsigned int n = 0; n < this->size_; n++)	84	for (unsigned int n = 0; n < this->size_; n++)
85	{	85	{
86	debug_string += boost::lexical_cast<std::string>((unsigned int)this->bytes_[n]) + ",";	86	debug_string += boost::lexical_cast<std::string>((unsigned int)this->bytes_[n]) + ",";
87	}	87	}
88		88
89	return debug_string;	89	return debug_string;
90	}	90	}
91		91
92	unsigned char& Byteset::operator[](unsigned int index)	92	unsigned char& Byteset::operator[](unsigned int index)
93	{	93	{
94	if (this->size_ < index + 1)	94	if (this->size_ < index + 1)
95	{	95	{
96	this->size_ = index + 1;	96	this->size_ = index + 1;
97	}	97	}
98		98
99	return this->bytes_[index];	99	return this->bytes_[index];
100	}	100	}
101		101
102	unsigned int Byteset::GetMaxSize() const	102	unsigned int Byteset::GetMaxSize() const
103	{	103	{
104	return this->max_size_;	104	return this->max_size_;
105	}	105	}
106		106
107	unsigned int Byteset::GetSize() const	107	unsigned int Byteset::GetSize() const
108	{	108	{
109	return this->size_;	109	return this->size_;
110	}	110	}
111		111
112	void Byteset::SetSize(unsigned int size)	112	void Byteset::SetSize(unsigned int size)
113	{	113	{
114	this->size_ = size;	114	this->size_ = size;
115	}	115	}
116		116
117	void Byteset::Append(unsigned char byte)	117	void Byteset::Append(unsigned char byte)
118	{	118	{
119	this->bytes_[this->size_] = byte;	119	this->bytes_[this->size_] = byte;
120	this->size_++;	120	this->size_++;
121	}	121	}
122		122
123	void Byteset::Clear()	123	void Byteset::Clear()
124	{	124	{
125	memset(this->bytes_, 0, this->max_size_);	125	memset(this->bytes_, 0, this->max_size_);
126	this->size_ = 0;	126	this->size_ = 0;
127	}	127	}
128		128
129	void Byteset::Fill(char c)	129	void Byteset::Fill(char c)
130	{	130	{
131	memset(this->bytes_, c, this->max_size_);	131	memset(this->bytes_, c, this->max_size_);
132	this->size_ = 0;	132	this->size_ = 0;
133	}	133	}
134		134
135	}; // namespace type	135	}; // namespace type
136	}; // namespace atom	136	}; // namespace atom
137		137