bool ON_Polyline::CreateStarPolygon(
const ON_Circle& circle,
double other_radius,
int side_count
)
{
bool rc = ( circle.IsValid() && side_count >= 3 && other_radius >= 0.0 )
? true
: false;
if ( rc )
{
SetCapacity(2*side_count+1);
SetCount(2*side_count+1);
double half_a = ON_PI/side_count;
int i;
ON_Circle other_circle = circle;
other_circle.radius = other_radius;
for ( i = 0; i < side_count; i++ )
{
m_a[i*2] = circle.PointAt(half_a*2*i);
m_a[i*2+1] = other_circle.PointAt(half_a*(1+2*i));
}
m_a[side_count*2] = m_a[0];
}
else
Destroy();
return rc;
}
ON_BOOL32 ON_BrepLoopArray::Read( ON_BinaryArchive& file )
{
Empty();
ON__UINT32 tcode = 0;
ON__INT64 length_TCODE_ANONYMOUS_CHUNK = 0;
int count = 0;
int i;
int major_version = 0;
int minor_version = 0;
bool rc = file.BeginRead3dmBigChunk( &tcode, &length_TCODE_ANONYMOUS_CHUNK );
if (rc) {
if (tcode != TCODE_ANONYMOUS_CHUNK)
rc = false;
if (rc) rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc) {
if ( major_version==1 ) {
if (rc) rc = file.ReadInt(&count);
SetCapacity(count);
for ( i = 0; i < count && rc ; i++ ) {
ON_BrepLoop& loop = AppendNew();
rc = loop.Read(file) ? true : false;
}
}
else {
rc = 0;
}
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
Bool CText::Serialize( CPersistentArchive& ar )
{
Int16 version = 0;
if( ar.BeginScope( WT("Text"), version ) == 0 )
{
ar.Serialize( m_Font, WT("Font") );
ar.Serialize( m_Capacity, WT("Capacity") );
ar.Serialize( m_Color, WT("Color") );
ar.Serialize( m_Position, WT("Position") );
ar.Serialize( m_FontSize, WT("FontSize") );
ar.Serialize( m_TextLength, WT("TextLen") );
if( ar.IsLoading() )
{
SetCapacity( m_Capacity );
m_State.SetBit( nState_UpdateBuffer );
m_State.SetBit( nState_RecreateBuffer );
}
ar.Serialize( m_Text.GetBuffer(), m_Capacity, WT("Text") );
ar.EndScope();
}
return CManagedObject::Serialize( ar );
}
/*
TLFObjectList
*/
TLFObjectList::TLFObjectList()
{
m_Count = 0;
m_Capacity = 0;
m_List = NULL;
SetCapacity(0);
}
bool ON_BrepRegionArray::Read( ON_BinaryArchive& file )
{
Empty();
int count = 0;
int i;
int major_version = 0;
int minor_version = 0;
bool rc = file.BeginRead3dmChunk( TCODE_ANONYMOUS_CHUNK, &major_version, &minor_version );
if (rc)
{
for(;;)
{
rc = (1 == major_version);
if (!rc) break;
if (rc) rc = file.ReadInt(&count);
SetCapacity(count);
for ( i = 0; i < count && rc ; i++ )
{
ON_BrepRegion& region = AppendNew();
rc = region.Read(file)?true:false;
}
break;
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
BOOL ON_BrepLoopArray::Read( ON_BinaryArchive& file )
{
Empty();
unsigned int tcode = 0;
int count = 0;
int i;
int major_version = 0;
int minor_version = 0;
BOOL rc = file.BeginRead3dmChunk( &tcode, &i );
if (rc) {
if (tcode != TCODE_ANONYMOUS_CHUNK)
rc = false;
if (rc) rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc) {
if ( major_version==1 ) {
if (rc) rc = file.ReadInt(&count);
SetCapacity(count);
for ( i = 0; i < count && rc ; i++ ) {
ON_BrepLoop& loop = AppendNew();
rc = loop.Read(file);
}
}
else {
rc = 0;
}
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
cxAtlas *cxAtlas::SetCoords(const cxArray *coords,const cxFrames *frames)
{
CX_ASSERT(!Size().IsZero(), "size not set");
cxInt size = frames->Num();
SetCapacity(size);
const cxInt *map = frames->Map();
for(cxInt i = 0;i < size;i++){
cxInt mapIdx = map[i];
CX_ASSERT(mapIdx < coords->Size(), "map idx error");
//get map tex
cxTexCoord *coord = coords->At(mapIdx)->To<cxTexCoord>();
if(coord->IsEmpty()){
continue;
}
//trimmed box
cxBoxPoint3F bp = coord->Trimmed(BoxPoint(), Size(), FlipX(), FlipY());
if(bp.Size().IsZero()){
continue;
}
//add render
cxBoxRender &render = renders.Inc();
render.SetVertices(bp);
render.SetColor(Color());
//get coord box
const cxBoxCoord2F &tbox = coord->BoxCoord(Pixel(), FlipX(), FlipY());
render.SetCoords(tbox);
}
return this;
}
FarString::FarStringData::FarStringData (const char *text, int length /*= -1*/)
: fText (NULL), fCapacity (0), fRefCount (1)
{
if (text)
{
if (length == -1)
fLength = strlen (text);
else
fLength = length;
}
else
{
if (length == -1)
fLength = 0;
else
fLength = length;
}
SetCapacity (fLength + 1);
if (text)
{
far_assert_string( text, fLength );
memcpy (fText, text, fLength );
fText[ fLength ] = '\0';
}
else
{
*fText = '\0';
fLength = 0;
}
}
void GrowCapacity(sPtr n)
{
if(Last+n>End)
{
sPtr count = Last-First;
SetCapacity(sMax(count+n,sMax(count*2,64/sizeof(T))));
}
}
bool
nsTSubstring_CharT::SetLength( size_type length )
{
if (!SetCapacity(length))
return false;
mLength = length;
return true;
}
CFreeList<DataType>::CFreeList( UInt32 size )
{
m_NextFree = 0;
m_Capacity = 0;
m_ItemCount = 0;
m_Array = NULL;
m_MemoryHeap = &MemoryManager.GetBuddyHeap();
SetCapacity( size );
}
void CIntArray::Add(int val)
{
if( aidx >= size )
{
SetCapacity(size+1);
}
arr[aidx] = val;
++aidx;
}
bool
nsTSubstring_CharT::SetLength( size_type length, const fallible_t& )
{
if (!SetCapacity(length, fallible_t()))
return false;
mLength = length;
return true;
}
nsresult
SVGPointList::CopyFrom(const SVGPointList& rhs)
{
if (!SetCapacity(rhs.Length())) {
// Yes, we do want fallible alloc here
return NS_ERROR_OUT_OF_MEMORY;
}
mItems = rhs.mItems;
return NS_OK;
}
void TMemoryStream::SetSize(const __int64 NewSize)
{
__int64 OldPosition = FPosition;
SetCapacity(NewSize);
FSize = NewSize;
if (OldPosition > NewSize)
{
Seek(0, Classes::soFromEnd);
}
}
cxAtlas *cxAtlas::SetScale9(const cxBox4F &sb)
{
if(scalebox != sb){
isscale9 = true;
scalebox = sb;
SetCapacity(9);
SetDirty(DirtyModeTexture);
}
return this;
}
void TLFObjectList::Grow()
{
int Delta;
if (m_Capacity > 64)
Delta = m_Capacity / 4;
else if (m_Capacity > 8)
Delta = 16;
else
Delta = 4;
SetCapacity(m_Capacity + Delta);
}
void TLFObjectList::Clear()
{
// SetCount(0);
for (int i = 0; i < this->m_Count; i++)
{
TLFObject* tmp = Get(i);
delete tmp;
tmp = NULL;
}
m_Count = 0;
SetCapacity(0);
}
void String::Resize(size_t newLength)
{
if (!buffer)
{
// If zero length requested, do not allocate buffer yet
if (!newLength)
return;
// Calculate initial capacity
size_t capacity = newLength + 1;
if (capacity < MIN_CAPACITY)
capacity = MIN_CAPACITY;
buffer = new char[capacity + 2 * sizeof(size_t)];
SetCapacity(capacity);
}
else
{
size_t capacity = Capacity();
if (newLength && capacity < newLength + 1)
{
// Increase the capacity with half each time it is exceeded
while (capacity < newLength + 1)
capacity += (capacity + 1) >> 1;
char* newBuffer = new char[capacity + 2 * sizeof(size_t)];
// Move the existing data to the new buffer, then delete the old buffer
if (Length())
CopyChars(newBuffer + 2 * sizeof(size_t), Buffer(), Length());
delete[] buffer;
buffer = newBuffer;
SetCapacity(capacity);
}
}
SetLength(newLength);
Buffer()[newLength] = 0;
}
CText::CText( const CTextFont& font, UInt32 capacity )
{
m_Size = CVector2i( 0, 0 );
m_FontSize = 1.0f;
m_Font = (CTextFont*) &font;
m_Color = CColor::White;
m_Capacity = 0;
SetCapacity( capacity );
m_Text[0] = 0;
m_TextLength = 0;
m_CtrlCharCount = 0;
m_State.SetBit( nState_RecreateBuffer );
}
bool SLGMRecord::SetField(FIELD_IDENTIFIERS, void *FieldValue, UINT32 ArraySize)
{
switch(FieldID)
{
case 1: //flags1
SetHeaderFlagMask(*(UINT32 *)FieldValue);
break;
case 3: //flags2
SetHeaderUnknownFlagMask(*(UINT32 *)FieldValue);
break;
case 4: //eid
EDID.Copy((STRING)FieldValue);
break;
case 5: //full
FULL.Copy((STRING)FieldValue);
break;
case 6: //modPath
MODL.Load();
MODL->MODL.Copy((STRING)FieldValue);
break;
case 7: //modb
MODL.Load();
MODL->MODB.value = *(FLOAT32 *)FieldValue;
break;
case 8: //modt_p
MODL.Load();
MODL->MODT.Copy((UINT8ARRAY)FieldValue, ArraySize);
break;
case 9: //iconPath
ICON.Copy((STRING)FieldValue);
break;
case 10: //script
SCRI.value = *(FORMID *)FieldValue;
return true;
case 11: //value
DATA.value.value = *(UINT32 *)FieldValue;
break;
case 12: //weight
DATA.value.weight = *(FLOAT32 *)FieldValue;
break;
case 13: //soulType
SetSoul(*(UINT8 *)FieldValue);
break;
case 14: //capacity
SetCapacity(*(UINT8 *)FieldValue);
break;
default:
break;
}
return false;
}
CText::CText( )
{
m_Size = CVector2i( 0, 0 );
m_FontSize = 1.0f;
m_Color = CColor::White;
m_Capacity = 0;
SetCapacity( 128 );
m_Text[0] = 0;
m_TextLength = 0;
m_CtrlCharCount = 0;
m_State.SetBit( nState_RecreateBuffer );
m_Font = &GraphicsManager.GetDefaultFont();
}
bool ON_3dPointArray::Create(
int point_dimension,
int bRational,
int point_count,
int point_stride,
const float* points
)
{
bool rc = false;
if ( point_dimension >= 2 && point_dimension <= 3
&& point_count>0 && points
&& point_stride >= bRational?(point_dimension+1):point_dimension )
{
rc = true;
int i;
ON_3dPoint q(0.0,0.0,0.0);
ON_4dPoint h(0.0,0.0,0.0,1.0);
m_count = 0;
SetCapacity(point_count);
SetCount(point_count);
if ( bRational )
{
for ( i = 0; i < point_count; i++ )
{
h.x = points[0];
h.y = points[1];
if ( point_dimension == 3 )
h.z = points[2];
h.w = points[point_dimension];
m_a[i] = h;
points += point_stride;
}
}
else
{
for ( i = 0; i < point_count; i++ )
{
q.x = points[0];
q.y = points[1];
if ( point_dimension == 3 )
q.z = points[2];
m_a[i] = q;
points += point_stride;
}
}
}
else
Destroy();
return rc;
}
cxAtlas *cxAtlas::SetCoords(const cxArray *coords)
{
cxInt size = coords->Size();
SetCapacity(size);
for(cxInt i = 0;i < size;i++){
cxBoxRender &render = renders.Inc();
cxTexCoord *coord = coords->At(i)->To<cxTexCoord>();
cxBoxPoint3F bp = coord->Trimmed(BoxPoint(), Size(), FlipX(), FlipY());
const cxBoxCoord2F &tbox = coord->BoxCoord(Pixel(), FlipX(), FlipY());
render.SetVertices(bp);
render.SetColor(Color());
render.SetCoords(tbox);
}
return this;
}
void
Filter::Append (byte value)
{
ASSERT (FilterSize <= Capacity);
FilterSize++;
if (value != 0) { FilterCount++; }
if( value == 1 && Data == NULL)
return;
if( value != 1 && Data == NULL)
Allocate();
else if (FilterSize > Capacity) {
// Data array is full, extend it in chunks of 1000:
SetCapacity(Capacity + 1000);
}
Data[FilterSize] = value;
}
void TLFObjectList::SetCount(int NewCount)
{
int i;
if (NewCount < 0)
return; //DONE: here is error
if (NewCount > m_Capacity)
SetCapacity(NewCount);
if (NewCount > m_Count)
memset(&m_List[m_Count],0,(NewCount - m_Count)*sizeof(TLFObject**));
else
for (i = m_Count -1; i >= NewCount; i--)
{
Delete(i);
}
m_Count = NewCount;
}
cudaError_t CudaAllocBuckets::Malloc(size_t size, void** p) {
// Locate the bucket index and adjust the size of the allocation to the
// bucket size.
int bucket = LocateBucket(size);
if(bucket < NumBuckets)
size = BucketSizes[bucket];
// Peel off an already-allocated node and reuse it.
MemList& list = _memLists[bucket];
if(list.size() && list.front().priority != _priorityMap.end()) {
MemList::iterator memIt = list.begin();
_priorityMap.erase(memIt->priority);
memIt->priority = _priorityMap.end();
list.splice(list.end(), list, memIt);
_committed += size;
*p = memIt->address->first;
return cudaSuccess;
}
// Shrink if this allocation would put us over the limit.
Compact(size);
cudaError_t error = cudaSuccess;
*p = 0;
if(size) error = cudaMalloc(p, size);
while((cudaErrorMemoryAllocation == error) && (_committed < _allocated)) {
SetCapacity(_capacity - _capacity / 10);
error = cudaMalloc(&p, size);
}
if(cudaSuccess != error) return error;
MemList::iterator memIt =
_memLists[bucket].insert(_memLists[bucket].end(), MemNode());
memIt->bucket = bucket;
memIt->address = _addressMap.insert(std::make_pair(*p, memIt)).first;
memIt->priority = _priorityMap.end();
_allocated += size;
_committed += size;
return cudaSuccess;
}
void String::Reserve(size_t newCapacity)
{
size_t length = Length();
if (newCapacity < length + 1)
newCapacity = length + 1;
if (newCapacity == Capacity())
return;
char* newBuffer = new char[newCapacity + 2 * sizeof(size_t)];
// Move the existing data to the new buffer (including the end zero), then delete the old buffer
if (length)
CopyChars(newBuffer + 2 * sizeof(size_t), Buffer(), length + 1);
delete[] buffer;
buffer = newBuffer;
SetLength(length);
SetCapacity(newCapacity);
}
ON_BOOL32 ON_BrepFaceArray::Read( ON_BinaryArchive& file )
{
Empty();
ON__UINT32 tcode = 0;
ON__INT64 length_TCODE_ANONYMOUS_CHUNK = 0;
int count = 0;
int i;
int major_version = 0;
int minor_version = 0;
bool rc = file.BeginRead3dmBigChunk( &tcode, &length_TCODE_ANONYMOUS_CHUNK );
if (rc) {
if (tcode != TCODE_ANONYMOUS_CHUNK)
rc = false;
if (rc) rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc) {
if ( major_version==1 )
{
if (rc) rc = file.ReadInt(&count);
SetCapacity(count);
for ( i = 0; i < count && rc ; i++ )
{
ON_BrepFace& face = AppendNew();
rc = face.Read(file)?true:false;
}
if ( minor_version >= 1 )
{
// chunk version 1.1 and later has face uuids
for ( i = 0; i < count && rc; i++ )
{
rc = file.ReadUuid( m_a[i].m_face_uuid );
}
}
}
else
{
rc = 0;
}
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
ON_BOOL32 ON_SurfaceArray::Read( ON_BinaryArchive& file )
{
int major_version = 0;
int minor_version = 0;
ON__UINT32 tcode = 0;
ON__INT64 big_value = 0;
int flag;
Destroy();
ON_BOOL32 rc = file.BeginRead3dmBigChunk( &tcode, &big_value );
if (rc)
{
rc = ( tcode == TCODE_ANONYMOUS_CHUNK );
if (rc) rc = file.Read3dmChunkVersion(&major_version,&minor_version);
if (rc && major_version == 1) {
ON_Object* p;
int count;
ON_BOOL32 rc = file.ReadInt( &count );
if (rc) {
SetCapacity(count);
SetCount(count);
Zero();
int i;
for ( i = 0; rc && i < count && rc; i++ ) {
flag = 0;
rc = file.ReadInt(&flag);
if (rc && flag==1) {
p = 0;
rc = file.ReadObject( &p ); // polymorphic surfaces
m_a[i] = ON_Surface::Cast(p);
if ( !m_a[i] )
delete p;
}
}
}
}
else {
rc = false;
}
if ( !file.EndRead3dmChunk() )
rc = false;
}
return rc;
}
