← Back to branch summary

~ubuntu-branches/ubuntu/precise/amule-adunanza/precise

« back to all changes in this revision

Viewing changes to src/RLE.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2010-02-18 21:16:23 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100218211623-gptwe60zx1knfkmu
Tags: 2010.1+2.2.6-0ubuntu1
https://launchpad.net/bugs/524697
* New upstream release (LP: #524697)
  - Drop manpages_spelling_fixes.diff fixed by upstream
  - Drop cryptopp-reference.diff fixed by upstream
  - Bump Standards-Version no changes required
  - Update install files (amule -> amuleadunanza)
  - debian/rules: amule.xpm -> amuleadunanza.xpm
  - Add README.Debian

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/RLE.cpp
1
1
//
2
2
// This file is part of the aMule Project.
3
3
//
4
 
// Copyright (c) 2003-2008 aMule Team ( admin@amule.org / http://www.amule.org )
 
4
// Copyright (c) 2003-2009 aMule Team ( admin@amule.org / http://www.amule.org )
5
5
//
6
6
// Any parts of this program derived from the xMule, lMule or eMule project,
7
7
// or contributed by third-party developers are copyrighted by their
35
35
 * We can't use implementation with "control char" since this encoder
36
36
 * will process binary data - not ascii (or unicode) strings
37
37
 */
 
38
 
 
39
// ADUNANZA BEGIN
 
40
// Backport
 
41
#if 0
38
42
RLE_Data::RLE_Data(int len, bool use_diff)
39
43
{
40
44
        m_len = len;
59
63
{
60
64
        m_len = obj.m_len;
61
65
        m_use_diff = obj.m_use_diff;
62
 
 
63
 
        m_buff = new unsigned char[m_len];
64
 
        memcpy(m_buff, obj.m_buff, m_len);
65
 
        
66
 
        m_enc_buff = new unsigned char[m_len*4/3 + 1];
67
 
}
68
 
 
69
 
RLE_Data &RLE_Data::operator=(const RLE_Data &obj)
70
 
{
71
 
        m_len = obj.m_len;
72
 
        
73
 
        m_use_diff = obj.m_use_diff;
74
 
 
75
 
        m_buff = new unsigned char[m_len];
76
 
        memcpy(m_buff, obj.m_buff, m_len);
77
 
        
78
 
        m_enc_buff = new unsigned char[m_len*4/3 + 1];
79
 
        
80
 
        return *this;
81
 
}
 
66
        m_buff = new unsigned char[m_len];
 
67
        memcpy(m_buff, obj.m_buff, m_len);
 
68
        
 
69
        m_enc_buff = new unsigned char[m_len*4/3 + 1];
 
70
}
 
71
 
 
72
RLE_Data &RLE_Data::operator=(const RLE_Data &obj)
 
73
{
 
74
        m_len = obj.m_len;
 
75
        
 
76
        m_use_diff = obj.m_use_diff;
 
77
 
 
78
        m_len = obj.m_len;
 
79
        
 
80
        m_use_diff = obj.m_use_diff;
 
81
 
 
82
        m_buff = new unsigned char[m_len];
 
83
        memcpy(m_buff, obj.m_buff, m_len);
 
84
        
 
85
        m_enc_buff = new unsigned char[m_len*4/3 + 1];
 
86
        return *this;
 
87
}
 
88
 
 
89
#else
 
90
 
 
91
void RLE_Data::setup(int len, bool use_diff, unsigned char * content)
 
92
{
 
93
        m_len = len;
 
94
        m_use_diff = use_diff;
 
95
 
 
96
        if (m_len) {
 
97
                m_buff = new unsigned char[m_len];
 
98
                if (content) {
 
99
                        memcpy(m_buff, content, m_len);
 
100
                } else {
 
101
                        memset(m_buff, 0, m_len);
 
102
                }
 
103
                //
 
104
                // in worst case 2-byte sequence encoded as 3. So, data can grow at 1/3
 
105
                m_enc_buff = new unsigned char[m_len*4/3 + 1];
 
106
        } else {
 
107
                m_buff = m_enc_buff = 0;
 
108
        }
 
109
}
 
110
 
 
111
RLE_Data &RLE_Data::operator=(const RLE_Data &obj)
 
112
{
 
113
        if (this == &obj)
 
114
                return *this;
 
115
 
 
116
        delete [] m_buff;
 
117
        delete [] m_enc_buff;
 
118
        setup(obj.m_len, obj.m_use_diff, obj.m_buff);
 
119
 
 
120
        return *this;
 
121
}
 
122
 
 
123
#endif
 
124
// ADUNANZA END
82
125
 
83
126
RLE_Data::~RLE_Data()
84
127
{