gecko-dev/lib/libaddr/abcell.cpp
1998-06-22 21:46:46 +00:00

346 lines
9.8 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
/* file: abcell.c
**
** Changes:
** <1> 02Dec1997 stubs
** <0> 22Oct1997 first draft
*/
#ifndef _ABTABLE_
#include "abtable.h"
#endif
#ifndef _ABMODEL_
#include "abmodel.h"
#endif
/*3456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678*/
/* ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- */
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
static const char* AB_Cell_kClassName /*i*/ = "AB_Cell";
#endif /* end AB_CONFIG_TRACE_orDEBUG_orPRINT*/
/*| Init: initialize and construct the cell so sCell_Size is at
**| least inMinSize bytes in size, and contains the content pointed
**| to by inStartingContent when inStartingContent is non-null.
**| If inStartingContent is null, then zero the initial content.
**| The inColumnUid arg cannot be zero or an error will occur; in
**| fact, inColumnUid must return true from AB_Uid_IsColumn().
**|
**|| If strlen(inStartingContent)+1 is greater than inMinSize, then
**| make a cell that size instead (the plus one is for a null byte). If
**| both inMinSize and the inStartingContent pointer are zero, allocate
**| at least a byte to avoid weird edge cases.
|*/
AB_MODEL_IMPL(ab_bool)
AB_Cell_Init(AB_Cell* self, ab_Env* ev, ab_column_uid inColumnUid, /*i*/
ab_cell_size inMinSize, const char* inStartingContent)
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "Init")
ab_cell_length length = 0; /* default to no content */
if ( !inMinSize ) /* need to make min size positive? */
inMinSize = 1;
if ( inStartingContent ) /* have initial content to use? */
{
length = strlen(inStartingContent);
if ( length+1 > inMinSize ) /* length requires more size? */
inMinSize = length+1;
}
if ( inMinSize <= AB_Cell_kMaxCellSize ) /* not too large? */
{
if ( AB_Uid_IsColumn(inColumnUid) ) /* column looks valid? */
{
char* content = (char*) ev->HeapSafeTagAlloc(inMinSize);
if ( content )
{
XP_MEMSET(content, 0, inMinSize); /* zero all content bytes*/
self->sCell_Column = inColumnUid;
self->sCell_Size = inMinSize;
self->sCell_Length = length;
self->sCell_Extent = 0; /* database must set this field */
self->sCell_Content = content;
if ( length ) /* any initial content to copy? */
XP_MEMCPY(content, inStartingContent, length);
}
}
else ev->NewAbookFault(AB_Cell_kFaultBadColumnUid);
}
else ev->NewAbookFault(AB_Cell_kFaultSizeExceedsMax);
ab_Env_EndMethod(ev)
return ev->Good();
}
/*| Finalize: deallocate sCell_Content and zero all slots.
|*/
AB_MODEL_IMPL(ab_bool)
AB_Cell_Finalize(AB_Cell* self, ab_Env* ev) /*i*/
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "Finalize")
if ( self->sCell_Content )
ev->HeapSafeTagFree(self->sCell_Content);
self->sCell_Column = 0;
self->sCell_Size = 0;
self->sCell_Length = 0;
self->sCell_Extent = 0;
self->sCell_Content = 0;
ab_Env_EndMethod(ev)
return ev->Good();
}
/*| Grow: increase the cell size sCell_Size to at least inMinSize
**| and reallocate the sCell_Content space if necessary. But if
**| sCell_Size is already that big, then do nothing.
**| True is returned if and only if the environment shows no errors.
|*/
AB_MODEL_IMPL(ab_bool)
AB_Cell_Grow(AB_Cell* self, ab_Env* ev, ab_cell_size inMinSize) /*i*/
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "Grow")
ab_cell_size oldSize = self->sCell_Size;
if ( oldSize < inMinSize ) /* need to grow content? */
{
if ( inMinSize <= AB_Cell_kMaxCellSize ) /* not too large? */
{
char* newContent = (char*) ev->HeapSafeTagAlloc(inMinSize);
if ( newContent ) /* allocated new content? */
{
char* oldContent = self->sCell_Content;
ab_num diffSize = inMinSize - oldSize; /* differential */
char* after = newContent + oldSize; /* after old content */
XP_MEMSET(after, 0, diffSize); /* clear after copied content */
if ( oldSize ) /* any old content to copy? */
XP_MEMCPY(newContent, oldContent, oldSize);
self->sCell_Content = newContent;
self->sCell_Size = inMinSize;
ev->HeapSafeTagFree(oldContent); /* discard old content space */
}
}
else ev->NewAbookFault(AB_Cell_kFaultSizeExceedsMax);
}
ab_Env_EndMethod(ev)
return ev->Good();
}
/*3456789_123456789_123456789_123456789_123456789_123456789_123456789_12345678*/
/*| Copy: make this cell contain the same content as other when capacity
**| is greater than other's content. Otherwise make self hold as much of
**| other's content as will fit without making self any larger. (This
**| method is intended to support AB_Tuple_CopyRowContent().)
**| True is returned if and only if the environment shows no errors.
|*/
AB_MODEL_IMPL(ab_bool)
AB_Cell_Copy(AB_Cell* self, ab_Env* ev, const AB_Cell* other)
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "Copy")
ab_cell_size selfSize = self->sCell_Size;
if ( selfSize ) /* receiver has some space as expected? */
{
char* selfContent = self->sCell_Content;
ab_cell_size selfRoom = selfSize - 1; /* less end null byte */
if ( selfRoom ) /* space for more than terminating null? */
{
ab_cell_size otherLength = other->sCell_Length;
if ( otherLength <= other->sCell_Size ) /* rational sizes? */
{
if ( otherLength > selfRoom ) /* too much content? */
otherLength = selfRoom; /* truncate to our capacity */
XP_MEMCPY(selfContent, other->sCell_Content, otherLength);
selfContent[ otherLength ] = 0; /* add end null byte */
self->sCell_Length = otherLength;
}
else ev->NewAbookFault(AB_Cell_kFaultLengthExceedsSize);
}
else
selfContent[ 0 ] = 0; /* can only hold empty string */
}
else ev->NewAbookFault(AB_Cell_kFaultZeroCellSize);
ab_Env_EndMethod(ev)
return ev->Good();
}
#if AB_CONFIG_TRACE_orDEBUG_orPRINT
AB_MODEL(char*) /* abcell.c */
AB_Cell_AsString(const AB_Cell* self, ab_Env* ev, char* outBuf) /*i*/
{
AB_Env* cev = ev->AsSelf();
const char* at = AB_ColumnUid_AsString(self->sCell_Column, cev);
if ( !at )
at = "<name>";
XP_SPRINTF(outBuf,
"<ab:cell:str val=\"%.48s\" at=\"#%lX/%.32s\" sz=\"#%lX\" ln=\"%lu\" ex=\"%lu\"/>",
self->sCell_Content, // val=\"%.64s\"
(long) self->sCell_Column, // at=\"#%lX
at, // %.32s\"
(long) self->sCell_Size, // sz=\"#%lX\"
(long) self->sCell_Length, // ln=\"%lu\"
(long) self->sCell_Extent // ex=\"%lu\"
);
return outBuf;
}
#endif /*AB_CONFIG_TRACE_orDEBUG_orPRINT*/
#ifdef AB_CONFIG_TRACE
AB_MODEL_IMPL(void) /* abcell.c */
AB_Cell_Trace(const AB_Cell* self, ab_Env* ev) /*i*/
{
char buf[ AB_Cell_kXmlBufSize ];
ev->Trace("%.250s", AB_Cell_AsString(self, ev, buf));
}
#endif /*AB_CONFIG_TRACE*/
#ifdef AB_CONFIG_DEBUG
AB_MODEL_IMPL(void) /* abcell.c */
AB_Cell_Break(const AB_Cell* self, ab_Env* ev) /*i*/
{
char buf[ AB_Cell_kXmlBufSize ];
ev->Break("%.250s", AB_Cell_AsString(self, ev, buf));
}
#endif /*AB_CONFIG_DEBUG*/
AB_MODEL(void) /* abcell.c */
AB_Cell_TraceAndBreak(const AB_Cell* self, ab_Env* ev) /*i*/
{
#ifdef AB_CONFIG_TRACE
AB_Cell_Trace(self, ev);
#endif /*AB_CONFIG_TRACE*/
#ifdef AB_CONFIG_DEBUG
AB_Cell_Break(self, ev);
#endif /*AB_CONFIG_DEBUG*/
}
AB_MODEL_IMPL(short) /* abcell.c */
AB_Cell_AsShort(const AB_Cell* self, ab_Env* ev) /*i*/
{
short outShort = 0;
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "AsShort")
char* content = self->sCell_Content;
if ( content )
{
if ( *content )
{
int value = 0;
int n = sscanf(content, "%d", &value);
outShort = value;
#ifdef AB_CONFIG_DEBUG
if ( n != 1 )
AB_Cell_Break(self, ev);
#endif /*AB_CONFIG_DEBUG*/
}
}
else ev->NewAbookFault(AB_Cell_kFaultNullContent);
ab_Env_EndMethod(ev)
return outShort;
}
AB_MODEL_IMPL(ab_bool) /* abcell.c */
AB_Cell_WriteHexLong(AB_Cell* self, ab_Env* ev, long inLong) /*i*/
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "WriteHexLong")
char* content = self->sCell_Content;
if ( content )
{
char buf[ 48 ];
XP_SPRINTF(buf, "%08lX", inLong );
XP_STRNCPY_SAFE(content, buf, self->sCell_Size);
self->sCell_Length = XP_STRLEN(content);
self->sCell_Extent = self->sCell_Length;
}
else ev->NewAbookFault(AB_Cell_kFaultNullContent);
ab_Env_EndMethod(ev)
return ev->Good();
}
AB_MODEL_IMPL(ab_bool) /* abcell.c */
AB_Cell_WriteShort(AB_Cell* self, ab_Env* ev, short inShort) /*i*/
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "WriteShort")
char* content = self->sCell_Content;
if ( content )
{
char buf[ 32 ];
XP_SPRINTF(buf, "%d", (int) ( inShort & 0x0FFFF ) );
XP_STRNCPY_SAFE(content, buf, self->sCell_Size);
self->sCell_Length = XP_STRLEN(content);
self->sCell_Extent = self->sCell_Length;
}
else ev->NewAbookFault(AB_Cell_kFaultNullContent);
ab_Env_EndMethod(ev)
return ev->Good();
}
AB_MODEL_IMPL(ab_bool) /* abcell.c */
AB_Cell_WriteBool(AB_Cell* self, ab_Env* ev, ab_bool inBool) /*i*/
{
ab_Env_BeginMethod(ev, AB_Cell_kClassName, "WriteBool")
char* content = self->sCell_Content;
if ( content )
{
if ( self->sCell_Size >= 2 )
{
if (inBool)
*content++ = 't';
else
*content++ = 'f';
*content = '\0';
self->sCell_Length = 1;
self->sCell_Extent = 1;
}
else ev->NewAbookFault(AB_Cell_kFaultSizeTooSmall);
}
else ev->NewAbookFault(AB_Cell_kFaultNullContent);
ab_Env_EndMethod(ev)
return ev->Good();
}