pegasus/src/Pegasus/Common/Buffer.cpp - diff

Return to Buffer.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Buffer.cpp between version 1.6 and 1.16

version 1.6, 2006/05/10 19:40:38

version 1.16, 2011/02/23 09:41:09

Line 1

//%2006////////////////////////////////////////////////////////////////////////

//%LICENSE////////////////////////////////////////////////////////////////

// Licensed to The Open Group (TOG) under one or more contributor license

// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.

// agreements. Refer to the OpenPegasusNOTICE.txt file distributed with

// this work for additional information regarding copyright ownership.

// IBM Corp.; EMC Corporation, The Open Group.

// Each contributor licenses this file to you under the OpenPegasus Open

// Source License; you may not use this file except in compliance with the

// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.

// License.

// EMC Corporation; VERITAS Software Corporation; The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the "Software"),

// EMC Corporation; Symantec Corporation; The Open Group.

// to deal in the Software without restriction, including without limitation

// the rights to use, copy, modify, merge, publish, distribute, sublicense,

// Permission is hereby granted, free of charge, to any person obtaining a copy

// and/or sell copies of the Software, and to permit persons to whom the

// of this software and associated documentation files (the "Software"), to

// Software is furnished to do so, subject to the following conditions:

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// The above copyright notice and this permission notice shall be included

// sell copies of the Software, and to permit persons to whom the Software is

// in all copies or substantial portions of the Software.

// furnished to do so, subject to the following conditions:

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

//////////////////////////////////////////////////////////////////////////

// Author: Michael E. Brasher (mike-brasher@austin.rr.com -- Inova Europe)

//%/////////////////////////////////////////////////////////////////////////////

Line 39

Line 35

PEGASUS_NAMESPACE_BEGIN

BufferRep Buffer::_empty_rep = { 0, 0, {0} };

// Note: _empty_rep is the only BufferRep object that may have a zero capacity.

static const size_t MIN_CAPACITY = 2048;

// So "_rep->cap == 0" implies "_rep == _empty_rep". But some platforms produce

// more than one instance of _empty_rep (strangely). Therefore, it is safer to

// use the former test rather than the latter.

BufferRep Buffer::_empty_rep =

{

0, /* size */

0, /* cap (zero implies it is the _empty_rep) */

{0} /* data[0] */

};

static Uint32 _next_pow_2(Uint32 x)

static Uint32 _next_pow_2(Uint32 x, Uint32 minCap)

{

// Check for potential overflow in x.

PEGASUS_CHECK_CAPACITY_OVERFLOW(x);

if (x < MIN_CAPACITY)

if (x < minCap)

return MIN_CAPACITY;

return minCap;

x--;

x |= (x >> 1);

Line 62

Line 67

return x;

}

static inline BufferRep* _allocate(size_t cap)

static inline BufferRep* _allocate(Uint32 cap, Uint32 minCap)

{

BufferRep* rep = (BufferRep*)malloc(sizeof(BufferRep) + cap);

if (cap < minCap)

cap = minCap;

// Allocate an extra byte for null-termination performed by getData().

BufferRep* rep = (BufferRep*)malloc(sizeof(BufferRep) + cap + 1);

if (!rep)

{

throw PEGASUS_STD(bad_alloc)();

Line 73

Line 83

return rep;

}

static inline BufferRep* _reallocate(BufferRep* rep, size_t cap)

static inline BufferRep* _reallocate(BufferRep* rep, Uint32 cap)

{

rep = (BufferRep*)realloc(rep, sizeof(BufferRep) + cap);

// Allocate an extra byte for null-termination performed by getData().

rep = (BufferRep*)realloc(rep, sizeof(BufferRep) + cap + 1);

if (!rep)

{

throw PEGASUS_STD(bad_alloc)();

Line 86

Line 98

Buffer::Buffer(const Buffer& x)

{

_rep = _allocate(x._rep->cap);

_rep = _allocate(x._rep->cap, x._minCap);

memcpy(_rep->data, x._rep->data, x._rep->size);

_rep->size = x._rep->size;

_minCap=x._minCap;

}

Buffer::Buffer(const char* data, size_t size)

Buffer::Buffer(const char* data, Uint32 size, Uint32 minCap): _minCap(minCap)

{

_rep = _allocate(size);

_rep = _allocate(size, _minCap);

_rep->size = size;

memcpy(_rep->data, data, size);

}

Line 104

Line 117

{

if (x._rep->size > _rep->cap)

{

if (_rep != &_empty_rep)

if (_rep->cap != 0)

free(_rep);

_rep = _allocate(x._rep->cap);

_rep = _allocate(x._rep->cap, x._minCap);

}

memcpy(_rep->data, x._rep->data, x._rep->size);

_rep->size = x._rep->size;

_minCap = x._minCap;

}

return *this;

}

void Buffer::_reserve_aux(size_t cap)

void Buffer::_reserve_aux(Uint32 cap)

{

if (_rep == &_empty_rep)

if (_rep->cap == 0)

{

_rep = _allocate(cap);

_rep = _allocate(cap, _minCap);

_rep->size = 0;

}

else

_rep = _reallocate(_rep, _next_pow_2(cap));

_rep = _reallocate(_rep, _next_pow_2(cap, _minCap));

}

void Buffer::_append_char_aux()

{

if (_rep == &_empty_rep)

if (_rep->cap == 0)

{

_rep = _allocate(MIN_CAPACITY);

_rep = _allocate(_minCap, _minCap);

_rep->size = 0;

}

else

{

// Check for potential overflow.

PEGASUS_CHECK_CAPACITY_OVERFLOW(_rep->cap);

_rep = _reallocate(_rep, _rep->cap ? (2 * _rep->cap) : MIN_CAPACITY);

_rep = _reallocate(_rep, _rep->cap ? (2 * _rep->cap) : _minCap);

}

void Buffer::insert(size_t pos, const char* data, size_t size)

void Buffer::insert(Uint32 pos, const char* data, Uint32 size)

{

if (pos > _rep->size)

return;

size_t cap = _rep->size + size;

Uint32 cap = _rep->size + size;

size_t rem = _rep->size - pos;

Uint32 rem = _rep->size - pos;

if (cap > _rep->cap)

{

BufferRep* rep = _allocate(cap);

BufferRep* rep = _allocate(cap, _minCap);

rep->size = cap;

memcpy(rep->data, _rep->data, pos);

memcpy(rep->data + pos, data, size);

memcpy(rep->data + pos + size, _rep->data + pos, rem);

if (_rep != &_empty_rep)

if (_rep->cap != 0)

free(_rep);

_rep = rep;

Line 172

Line 186

}

void Buffer::remove(size_t pos, size_t size)

void Buffer::insertWithOverlay(

Uint32 pos,

const char* data,

Uint32 size,

Uint32 overlay)

{

if (pos > _rep->size)

return;

Uint32 rem = _rep->size - pos;

memmove(_rep->data + pos + size - overlay, _rep->data + pos, rem);

memcpy(_rep->data + pos, data, size);

_rep->size += (size-overlay);

}

void Buffer::remove(Uint32 pos, Uint32 size)

{

if (pos + size > _rep->size)

return;

size_t rem = _rep->size - (pos + size);

Uint32 rem = _rep->size - (pos + size);

if (rem)

memmove(_rep->data + pos, _rep->data + pos + size, rem);

Legend:

Removed from v.1.6
changed lines
	Added in v.1.16

No CVS admin address has been configured