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()
{
    delete [] this->bytes_;
}
 
unsigned char* Byteset::Get() const
{
    return this->bytes_;
}
 
std::string Byteset::ToCharString()
{
    return std::string((char*)this->bytes_, this->size_ - 1);
}
 
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
 

Rev 1608	Rev 1642
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 ~~type~~ {	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()	56	Byteset::~Byteset()
57	{	57	{
58	delete [] this->bytes_;	58	delete [] this->bytes_;
59	}	59	}
60		60
61	unsigned char* Byteset::Get() const	61	unsigned char* Byteset::Get() const
62	{	62	{
63	return this->bytes_;	63	return this->bytes_;
64	}	64	}
65		65
66	std::string Byteset::ToCharString()	66	std::string Byteset::ToCharString()
67	{	67	{
68	return std::string((char*)this->bytes_, this->size_ - 1);	68	return std::string((char*)this->bytes_, this->size_ - 1);
69	}	69	}
70		70
71	std::string Byteset::ToDebugString()	71	std::string Byteset::ToDebugString()
72	{	72	{
73	std::string debug_string;	73	std::string debug_string;
74		74
75	for (unsigned int n = 0; n < this->size_; n++)	75	for (unsigned int n = 0; n < this->size_; n++)
76	{	76	{
77	debug_string += boost::lexical_cast<std::string>((unsigned int)this->bytes_[n]) + ",";	77	debug_string += boost::lexical_cast<std::string>((unsigned int)this->bytes_[n]) + ",";
78	}	78	}
79		79
80	return debug_string;	80	return debug_string;
81	}	81	}
82		82
83	unsigned char& Byteset::operator[](unsigned int index)	83	unsigned char& Byteset::operator[](unsigned int index)
84	{	84	{
-		85	if (this->size_ < index + 1)
-		86	{
-		87	this->size_ = index + 1;
-		88	}
-		89
85	return this->bytes_[index];	90	return this->bytes_[index];
86	}	91	}
87		92
88	unsigned int Byteset::GetMaxSize() const	93	unsigned int Byteset::GetMaxSize() const
89	{	94	{
90	return this->max_size_;	95	return this->max_size_;
91	}	96	}
92		97
93	unsigned int Byteset::GetSize() const	98	unsigned int Byteset::GetSize() const
94	{	99	{
95	return this->size_;	100	return this->size_;
96	}	101	}
97		102
98	void Byteset::SetSize(unsigned int size)	103	void Byteset::SetSize(unsigned int size)
99	{	104	{
100	this->size_ = size;	105	this->size_ = size;
101	}	106	}
102		107
103	void Byteset::Append(unsigned char byte)	108	void Byteset::Append(unsigned char byte)
104	{	109	{
105	this->bytes_[this->size_] = byte;	110	this->bytes_[this->size_] = byte;
106	this->size_++;	111	this->size_++;
107	}	112	}
108		113
109	void Byteset::Clear()	114	void Byteset::Clear()
-		115	{
-		116	memset(this->bytes_, 0, this->max_size_);
-		117	this->size_ = 0;
-		118	}
-		119
-		120	void Byteset::Fill(char c)
110	{	121	{
111	memset(this->bytes_, 0, this->max_size_);	122	memset(this->bytes_, c, this->max_size_);
112	this->size_ = 0;	123	this->size_ = 0;
113	}	124	}
114		125
115	}; // namespace type	126	}; // namespace type
116	}; // namespace atom	127	}; // namespace atom
117		128

Subversion Repositories HomeAutomation

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