ON_String::ON_String( const unsigned char* s, int length )
{
Create();
if ( s && length > 0 ) {
CopyToArray(length,s);
}
}
ON_wString::ON_wString( const wchar_t* s, int length )
{
Create();
if ( s && length > 0 ) {
CopyToArray( length, s );
}
}
ON_wString::ON_wString( const unsigned char* s )
{
Create();
if ( s && s[0] ) {
CopyToArray( (int)strlen((const char*)s), (const char*)s ); // the (int) is for 64 bit size_t conversion
}
}
ON_wString::ON_wString( const wchar_t* s )
{
Create();
if ( s && s[0] ) {
CopyToArray( (int)wcslen(s), s ); // the (int) is for 64 bit size_t conversion
}
}
ON_String::ON_String( const char* s )
{
Create();
if ( s && s[0] ) {
CopyToArray( (int)strlen(s), s ); // the (int) is for 64 bit size_t conversion
}
}
ON_String::ON_String( const wchar_t* w, int w_length )
{
// from substring
Create();
if ( w && w[0] ) {
CopyToArray( w_length, w );
}
}
static inline bool
Run(const char *path, Args... args)
{
constexpr unsigned n = sizeof...(Args);
const char *argv[1 + n + 1];
CopyToArray(argv, path, args...);
return Run(argv);
}
ON_String& ON_String::operator=( const wchar_t* w )
{
// converts wide string to byt string
int w_length = 0;
if ( w ) while ( w[w_length] ) w_length++;
CopyToArray( w_length, w);
return *this;
}
size_t NDMask::MaskedCount() const
{
auto maskMatrix = GetMatrix();
std::unique_ptr<char[]> maskData(maskMatrix->CopyToArray());
return std::count_if(maskData.get(), maskData.get() + maskMatrix->GetNumElements(), [](const char& val) {
return val == 0;
});
}
void ON_String::CopyArray()
{
// If 2 or more strings are using the array, it is duplicated.
// Call CopyArray() before modifying array contents.
ON_aStringHeader* p = Header();
if ( p != pEmptyStringHeader && p && p->ref_count > 1 ) {
const char* s = m_s;
Destroy();
CopyToArray( p->string_capacity, s );
}
}
void ON_String::CopyToArray( int w_count, const wchar_t* w )
{
// convert UTF-16 string to UTF-8 string
int c_count = w2c_size( w_count, w );
char* c = (char*)onmalloc(c_count+1);
memset( c, 0, c_count+1 );
const int c_length = w2c( w_count, w, c_count, c );
c[c_length] = 0;
CopyToArray( c_count, c );
onfree(c);
}
bool ON_String::LoadResourceString( HINSTANCE instance, UINT id )
{
char s[2048]; // room for 2047 characters
int length;
Destroy();
length = ::LoadStringA( instance, id, s, 2047 );
if ( length > 0 && length < 2048 ) {
CopyToArray( length, s );
}
return (length > 0 );
}
ON_wString::ON_wString( unsigned char c, int repeat_count )
{
Create();
if ( repeat_count > 0 ) {
char* s = (char*)onmalloc((repeat_count+1)*sizeof(*s));
s[repeat_count] = 0;
memset( s, c, repeat_count*sizeof(*s) );
CopyToArray( repeat_count, s );
onfree(s);
m_s[repeat_count] = 0;
Header()->string_length = repeat_count;
}
}
bool ON_wString::LoadResourceString(HINSTANCE instance, UINT id )
{
bool rc = false;
wchar_t s[2048]; // room for 2047 characters
int length;
Destroy();
length = ::LoadStringW( instance, id, s, 2047 );
if ( length > 0 && length < 2048 ) {
CopyToArray( length, s );
rc = true;
}
return rc;
}
void ON_String::CopyArray()
{
// If 2 or more strings are using the array, it is duplicated.
// Call CopyArray() before modifying array contents.
ON_aStringHeader* p = Header();
if ( p != pEmptyStringHeader && p && p->ref_count > 1 )
{
const char* s = m_s;
// p and s remain valid after Destroy() because
// will simply be decremented and no deallocation
// will happen.
Destroy();
CopyToArray( p->string_capacity, s );
if ( p->string_length < p->string_capacity )
{
Header()->string_length = p->string_length;
}
}
}
void ON_MSC_CDECL ON_String::Format( const unsigned char* sFormat, ...)
{
#define MAX_MSG_LENGTH 2048
char sMessage[MAX_MSG_LENGTH];
va_list args;
/* put formatted message in sMessage */
memset(sMessage,0,sizeof(sMessage));
if (sFormat) {
va_start(args, sFormat);
on_vsnprintf(sMessage, MAX_MSG_LENGTH-1, (const char*)sFormat, args);
sMessage[MAX_MSG_LENGTH-1] = 0;
va_end(args);
}
const int len = Length(sMessage);
if ( len < 1 ) {
Destroy();
Create();
}
else {
ReserveArray( len );
CopyToArray( len, sMessage );
}
}
/**
Function to convert CMPIValue to CIMValue
*/
CIMValue value2CIMValue(const CMPIValue* data, const CMPIType type, CMPIrc *rc)
{
CIMValue v;
if( rc )
{
*rc=CMPI_RC_OK;
}
/**
check data for NULL if type is not CMPIArray.
*/
if( !(type & CMPI_ARRAY) && !data )
{
return CIMValue(type2CIMType(type), false);
}
/**
Case when type is CMPIArray
*/
if( type & CMPI_ARRAY )
{
//Return if data itself is NULL or Array is NULL
if( data == NULL || data->array == NULL )
{
CMPIType aType=type&~CMPI_ARRAY;
return CIMValue(type2CIMType(aType),true);
}
// When data is not NULL and data->array is also set
CMPIArray *ar=data->array;
CMPIData *aData=(CMPIData*)((CMPI_Array*)ar->hdl)->hdl;
//Get the type of the elements in the array
CMPIType aType=aData->type&~CMPI_ARRAY;
int aSize=aData->value.sint32;
aData++;
// Checks for Signed Integers
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_SINT )
{
switch( aType )
{
case CMPI_sint32:
CopyToArray(Sint32,sint32);
break;
case CMPI_sint16:
CopyToArray(Sint16,sint16);
break;
case CMPI_sint8:
CopyToArray(Sint8,sint8);
break;
case CMPI_sint64:
CopyToArray(Sint64,sint64);
break;
default: ;
}
}
else
if( aType == CMPI_chars )
{
CopyToStringArray(String,string->hdl)
}
else
if( aType == CMPI_charsptr )
{
CopyCharsptrToStringArray(String,chars)
}
else
if( aType == CMPI_string )
{
CopyToStringArray(String,string->hdl)
}
// Checks for Unsigned Integers
else
if( (aType & (CMPI_UINT|CMPI_SINT))==CMPI_UINT )
{
switch( aType )
{
case CMPI_uint32:
CopyToArray(Uint32,uint32);
break;
case CMPI_uint16:
CopyToArray(Uint16,uint16);
break;
case CMPI_uint8:
CopyToArray(Uint8,uint8);
break;
case CMPI_uint64:
CopyToArray(Uint64,uint64);
break;
default: ;
}
}
else
{
switch( aType )
{
case CMPI_ref:
{
Array<CIMObjectPath> arCIMObjectPath(aSize);
ArrayIterator<CIMObjectPath> iterator(arCIMObjectPath);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.ref->hdl;
scmoInst->getCIMObjectPath(iterator[i]);
}
v.set(arCIMObjectPath);
}
break;
case CMPI_dateTime:
CopyToEncArray(CIMDateTime,dateTime);
break;
case CMPI_instance:
{
Array<CIMObject> arCIMInstance(aSize);
ArrayIterator<CIMObject> iterator(arCIMInstance);
for (int i=0; i<aSize; i++)
{
SCMOInstance* scmoInst =
(SCMOInstance*)aData[i].value.inst->hdl;
CIMInstance inst;
scmoInst->getCIMInstance(inst);
CIMObject obj(inst);
iterator[i]=obj;
}
v.set(arCIMInstance);
}
break;
case CMPI_boolean:
CopyToArray(Boolean,boolean);
break;
case CMPI_char16:
CopyToArray(Char16,char16);
break;
case CMPI_real32:
CopyToArray(Real32,real32);
break;
case CMPI_real64:
CopyToArray(Real64,real64);
break;
default:
if( rc )
{
*rc=CMPI_RC_ERR_NOT_SUPPORTED;
}
}
}
return CIMValue(v);
} // end of array processing
//Start of non - array types processing
else
if( type == CMPI_chars )
const ON_wString& ON_wString::operator=( wchar_t c )
{
CopyToArray( 1, &c );
return *this;
}
const ON_wString& ON_wString::operator=( const wchar_t* s )
{
if ( (void*)s != (void*)m_s )
CopyToArray( Length(s), s);
return *this;
}
ON_String& ON_String::operator=( const unsigned char* s )
{
if ( (void*)s != (void*)m_s )
CopyToArray( Length(s), s);
return *this;
}
ON_String& ON_String::operator=( unsigned char c )
{
CopyToArray( 1, &c );
return *this;
}
static inline void
CopyToArray(const char **dest, const char *src, Args... args)
{
*dest++ = src;
CopyToArray(dest, args...);
}
void ON_String::CopyToArray( const ON_String& s )
{
CopyToArray( s.Length(), s.Array() );
}
void ON_String::CopyToArray( int size, const unsigned char* s )
{
CopyToArray( size, ((char*)s) );
}
