archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/admin/cmdline/lib/dynarray.c

5740 lines
152 KiB
Raw Blame History

/***************************************************************************************
Copyright (c) Microsoft Corporation
Module Name:
DynArray.C
Abstract:
This module deals with the various functionalities such as creation of DynamicArrays, deletion of Dynamic Arrays,insertion
of elements into Dynamic Arrays and various other related functionalities.
Author:
G.V.N Murali Sunil. 1-9-2000
Revision History :
***************************************************************************************/
#include "pch.h"
#include "cmdline.h"
//
// constants / compiler defines / enumerations
//
// signatures
#define _SIGNATURE_ARRAY 9
#define _SIGNATURE_ITEM 99
// hidden item types
#define _TYPE_NEEDINIT DA_TYPE_NONE
//
// private structures ... structures declared in this area are not exposed to
// the external world ... hidden structures
//
// represents array item
typedef struct __tagItem
{
DWORD dwSignature; // signature ... used for validation
DWORD dwType; // says the type of the current item
DWORD dwSize; // size of the memory allocated
LPVOID pValue; // value of the item ( address )
struct __tagItem* pNext; // pointer to the next item
} __TITEM;
typedef __TITEM* __PTITEM; // pointer typedefintion
// represents the array
typedef struct __tagArray
{
DWORD dwSignature; // signature ... for validating pointer
DWORD dwCount; // count of items in the array
__PTITEM pStart; // pointer to the first item
__PTITEM pLast; // pointer to the last item
} __TARRAY;
typedef __TARRAY* __PTARRAY; // pointer typedefintion
//
// private function(s) ... used only in this file
//
__PTITEM
__DynArrayGetItem(
TARRAY pArray,
DWORD dwIndex,
__PTITEM* ppPreviousItem
)
/*++
Routine Description:
To append any type of item into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dwIndex - Index of the item
[ in ] ppPreviousItem - pointer to the previous item.
Return Value:
Pointer to the structure containing the Item.
--*/
{
// local variables
DWORD i = 0 ;
__PTITEM pItem = NULL;
__PTITEM pPrevItem = NULL;
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return NULL;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// check the size of the array with the position of the item required
// if the size is less, return NULL
if ( pArrayEx->dwCount <= dwIndex )
{
return NULL;
}
// traverse thru the list and find the appropriate item
pPrevItem = NULL;
pItem = pArrayEx->pStart;
for( i = 1; i <= dwIndex; i++ )
{
// store the current pointer and fetch the next pointer
pPrevItem = pItem;
pItem = pItem->pNext;
}
// if the previous pointer is also requested, update the previous pointer
if ( NULL != ppPreviousItem ) { *ppPreviousItem = pPrevItem; }
// now return the __TITEM pointer
return pItem;
}
LONG
__DynArrayAppend(
TARRAY pArray,
DWORD dwType,
DWORD dwSize,
LPVOID pValue
)
/*++
Routine Description:
To append any type of item into the Dynamic Array.
Arguments:
[ in ] pArray - Dynamic Array containing the result.
[ in ] dwType - type of the item.
[ in ] dwSize - Size of the item.
[ in ] pValue - pointer to the Item.
Return Value:
If successfully added the item to the list then return index else -1.
--*/
{
// local variables
__PTITEM pItem = NULL;
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// Check for overflow condition.
if( ULONG_MAX == pArrayEx->dwCount )
{
return -1;
}
// create an item and check the result. if memory allocation failed, error
pItem = ( __PTITEM ) AllocateMemory( sizeof( __TITEM ) );
if ( NULL == pItem )
{
return -1;
}
// initialize the newly allocated item structure with appropriate data
pItem->pNext = NULL;
pItem->dwType = dwType;
pItem->dwSize = dwSize;
pItem->pValue = pValue;
pItem->dwSignature = _SIGNATURE_ITEM;
pArrayEx->dwCount++; // update the count of items in array info
// now add the newly created item to the array at the end of the list
if ( NULL == pArrayEx->pStart )
{
// first item in the array
pArrayEx->pStart = pArrayEx->pLast = pItem;
}
else
{
// appending to the existing list
pArrayEx->pLast->pNext = pItem;
pArrayEx->pLast = pItem;
}
// successfully added the item to the list ... return index
return ( pArrayEx->dwCount - 1 ); // count - 1 = index
}
LONG
__DynArrayInsert(
TARRAY pArray,
DWORD dwIndex,
DWORD dwType,
DWORD dwSize,
LPVOID pValue
)
/*++
Routine Description:
To insert an item into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dwIndex - index of the item
[ in ] dwType - type of the item
[ in ] dwSize - Size to the Item.
[ in ] pValue - pointer to the item.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
DWORD i = 0;
__PTITEM pItem = NULL;
__PTITEM pBeforeInsert = NULL;
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// Check for overflow condition.
if( ULONG_MAX == pArrayEx->dwCount )
{
return -1;
}
// check the size of the array with the position of the insertion that has to be done
// if the size is less, treat this call as just a call to Append function
if ( pArrayEx->dwCount <= dwIndex )
{
return __DynArrayAppend( pArray, dwType, dwSize, pValue );
}
// create an item and check the result. if memory allocation failed, error
pItem = ( __PTITEM ) AllocateMemory( sizeof( __TITEM ) );
if ( NULL == pItem )
{
return -1;
}
// initialize the newly allocated item structure with appropriate data
pItem->pNext = NULL;
pItem->dwType = dwType;
pItem->dwSize = dwSize;
pItem->pValue = pValue;
pItem->dwSignature = _SIGNATURE_ITEM;
// update the count of the array items
pArrayEx->dwCount++;
// check whether the new item has to be added at the begining of the list
if ( 0 == dwIndex )
{
// put the new item at the begining of the list
pItem->pNext = pArrayEx->pStart;
pArrayEx->pStart = pItem;
// return as the operation is completed
return TRUE;
}
// traverse thru the list and find the location where the insertion of
// new element has to be done
pBeforeInsert = pArrayEx->pStart;
for( i = 0; i < dwIndex - 1; i++ )
{
pBeforeInsert = pBeforeInsert->pNext;
}
// insert the new item at the new location and update the chain
pItem->pNext = pBeforeInsert->pNext;
pBeforeInsert->pNext = pItem;
// return as the operation is completed ... return index position
return dwIndex; // passed index itself is return value
}
VOID
__DynArrayFreeItemValue(
__PTITEM pItem
)
/*++
// ***************************************************************************
Routine Description:
Frees the items present in a Dynamic array
Arguments:
[ in ] pItem - pointer to the item to be freed
Return Value:
none
--*/
{
// validate the pointer
if ( NULL == pItem )
{
return;
}
// now free the items value based on its type
switch( pItem->dwType )
{
case DA_TYPE_STRING:
case DA_TYPE_LONG:
case DA_TYPE_DWORD:
case DA_TYPE_BOOL:
case DA_TYPE_FLOAT:
case DA_TYPE_DOUBLE:
case DA_TYPE_HANDLE:
case DA_TYPE_SYSTEMTIME:
case DA_TYPE_FILETIME:
FreeMemory( &( pItem->pValue ) ); // free the value
break;
case DA_TYPE_GENERAL:
break; // user program itself should de-allocate memory for this item
case _TYPE_NEEDINIT:
break; // memory is not yet allocated for value of this item
case DA_TYPE_ARRAY:
// destroy the dynamic array
DestroyDynamicArray( &pItem->pValue );
pItem->pValue = NULL;
break;
default:
break;
}
// return
return;
}
LONG
__DynArrayFind(
TARRAY pArray,
DWORD dwType,
LPVOID pValue,
BOOL bIgnoreCase,
DWORD dwCount
)
/*++
Routine Description:
To find an item in the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dwType - type of the item
[ in ] pValue - Conatains value of the new item.
[ in ] bIgnoreCase - boolean indicating if the search is
case-insensitive
[ in ] dwCount - Contains number characters to compare
for a string item.
Return Value:
If successfully found the item in the DynamicArray then return index
-1 in case of error.
--*/
{
// local variables
DWORD dw = 0;
__PTITEM pItem = NULL;
__PTARRAY pArrayEx = NULL;
// temp variables
FILETIME* pFTime1 = NULL;
FILETIME* pFTime2 = NULL;
SYSTEMTIME* pSTime1 = NULL;
SYSTEMTIME* pSTime2 = NULL;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// get the reference to the actual array
pArrayEx = ( __PTARRAY ) pArray;
// now traverse thru the array and search for the requested value
pItem = pArrayEx->pStart;
for ( dw = 0; dw < pArrayEx->dwCount; pItem = pItem->pNext, dw++ )
{
// before checking the value, check the data type of the item
if ( pItem->dwType != dwType )
{
continue; // item is not of needed type, skip this item
}
// now check the value of the item with the needed value
switch ( dwType )
{
case DA_TYPE_LONG:
{
// value of type LONG
if ( *( ( LONG* ) pItem->pValue ) == *( ( LONG* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_DWORD:
{
// value of type DWORD
if ( *( ( DWORD* ) pItem->pValue ) == *( ( DWORD* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_FLOAT:
{
// value of type float
if ( *( ( float* ) pItem->pValue ) == *( ( float* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_DOUBLE:
{
// value of type double
if ( *( ( double* ) pItem->pValue ) == *( ( double* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_HANDLE:
{
// value of type HANDLE
if ( *( ( HANDLE* ) pItem->pValue ) == *( ( HANDLE* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_STRING:
{
// value of type string
if ( StringCompare( (LPCWSTR) pItem->pValue,
(LPCWSTR) pValue, bIgnoreCase, dwCount ) == 0 )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_FILETIME:
{
// get the values ( for readability sake )
pFTime1 = ( FILETIME* ) pValue;
pFTime2 = ( FILETIME* ) pItem->pValue;
if ( pFTime1->dwHighDateTime == pFTime2->dwHighDateTime &&
pFTime1->dwLowDateTime == pFTime2->dwLowDateTime )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_SYSTEMTIME:
{
// get the values ( for readability sake )
pSTime1 = ( SYSTEMTIME* ) pValue;
pSTime2 = ( SYSTEMTIME* ) pItem->pValue;
if ( pSTime1->wDay == pSTime2->wDay &&
pSTime1->wDayOfWeek == pSTime1->wDayOfWeek &&
pSTime1->wHour == pSTime1->wHour &&
pSTime1->wMilliseconds == pSTime2->wMilliseconds &&
pSTime1->wMinute == pSTime2->wMinute &&
pSTime1->wMonth == pSTime2->wMonth &&
pSTime1->wSecond == pSTime2->wSecond &&
pSTime1->wYear == pSTime2->wYear )
{
return dw; // value matched
}
// break the case
break;
}
default:
{
// just break ... nothin special to do
break;
}
}
}
// value not found
return -1;
}
LONG
__DynArrayFindEx(
TARRAY pArray,
DWORD dwColumn,
DWORD dwType,
LPVOID pValue,
BOOL bIgnoreCase,
DWORD dwCount
)
/*++
Routine Description:
To find an item in the a 2 dimensional Dynamic Array .
this function is private to this module only.
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dwColumn - The number of columns
[ in ] dwType - type of the item
[ in ] pValue - Size to the Item.
[ in ] bIgnoreCase - boolean indicating if the search is case-insensitive
[ in ] dwCount - used in case of string type comparisions. The number of
characters that have to be compared in a particular column.
Return Value:
If successfully found the item in the DynamicArray then return index
-1 in case of error.
--*/
{
// local variables
DWORD dw = 0;
__PTITEM pItem = NULL;
__PTITEM pColumn = NULL;
__PTARRAY pArrayEx = NULL;
// temp variables
FILETIME* pFTime1 = NULL;
FILETIME* pFTime2 = NULL;
SYSTEMTIME* pSTime1 = NULL;
SYSTEMTIME* pSTime2 = NULL;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// get the reference to the actual array
pArrayEx = ( __PTARRAY ) pArray;
// now traverse thru the array and search for the requested value
pItem = pArrayEx->pStart;
for ( dw = 0; dw < pArrayEx->dwCount; pItem = pItem->pNext, dw++ )
{
// check whether the current value is of ARRAY type or not
if ( DA_TYPE_ARRAY != pItem->dwType )
{
continue; // item is not of ARRAY type, skip this item
}
// now get the item at the required column
pColumn = __DynArrayGetItem( pItem->pValue, dwColumn, NULL );
if ( NULL == pColumn )
{
continue; // column not found ... skip this item
}
// get the type of the column value
if ( pColumn->dwType != dwType )
{
continue; // column is not of needed type, skip this item also
}
// now check the value of the column with the needed value
switch ( dwType )
{
case DA_TYPE_LONG:
{
// value of type LONG
if ( *( ( LONG* ) pColumn->pValue ) == *( ( LONG* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_DWORD:
{
// value of type DWORD
if ( *( ( DWORD* ) pColumn->pValue ) == *( ( DWORD* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_FLOAT:
{
// value of type float
if ( *( ( float* ) pColumn->pValue ) == *( ( float* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_DOUBLE:
{
// value of type double
if ( *( ( double* ) pColumn->pValue ) == *( ( double* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_HANDLE:
{
// value of type HANDLE
if ( *( ( HANDLE* ) pColumn->pValue ) == *( ( HANDLE* ) pValue ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_STRING:
{
// value of type string
if ( 0 == StringCompare( (LPCWSTR) pColumn->pValue,
(LPCWSTR) pValue, bIgnoreCase, dwCount ) )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_FILETIME:
{
// get the values ( for readability sake )
pFTime1 = ( FILETIME* ) pValue;
pFTime2 = ( FILETIME* ) pItem->pValue;
if ( pFTime1->dwHighDateTime == pFTime2->dwHighDateTime &&
pFTime1->dwLowDateTime == pFTime2->dwLowDateTime )
{
return dw; // value matched
}
// break the case
break;
}
case DA_TYPE_SYSTEMTIME:
{
// get the values ( for readability sake )
pSTime1 = ( SYSTEMTIME* ) pValue;
pSTime2 = ( SYSTEMTIME* ) pItem->pValue;
if ( pSTime1->wDay == pSTime2->wDay &&
pSTime1->wDayOfWeek == pSTime1->wDayOfWeek &&
pSTime1->wHour == pSTime1->wHour &&
pSTime1->wMilliseconds == pSTime2->wMilliseconds &&
pSTime1->wMinute == pSTime2->wMinute &&
pSTime1->wMonth == pSTime2->wMonth &&
pSTime1->wSecond == pSTime2->wSecond &&
pSTime1->wYear == pSTime2->wYear )
{
return dw; // value matched
}
// break the case
break;
}
default:
{
// just break ... nothing special to do
break;
}
}
}
// value not found
return -1;
}
/*******************************************/
/*** IMPLEMENTATION OF PUBLIC FUNCTIONS ***/
/*******************************************/
BOOL
IsValidArray(
TARRAY pArray
)
/*++
Routine Description:
Validate the array
Arguments:
[ in ] pArray - Dynamic Array
Return Value:
TRUE - if it is a valid array else FALSE
--*/
{
// check the signature
return ( ( NULL != pArray ) &&
( _SIGNATURE_ARRAY == ( ( __PTARRAY ) pArray )->dwSignature ) );
}
TARRAY
CreateDynamicArray()
/*++
Routine Description:
This function creates a dynamic array.
Arguments:
None.
Return Value:
pointer to the newly created array
--*/
{
// local variables
__PTARRAY pArray;
// memory allocation ... array is being created
pArray = ( __PTARRAY ) AllocateMemory( 1 * sizeof( __TARRAY ) );
// check the allocation result
if ( NULL == pArray )
{
return NULL;
}
// initialize the structure variables
pArray->dwCount = 0;
pArray->pStart = NULL;
pArray->pLast = NULL;
pArray->dwSignature = _SIGNATURE_ARRAY;
// return array reference
return pArray;
}
VOID
DynArrayRemoveAll(
TARRAY pArray
)
/*++
Routine Description:
traverse thru the Dynamic Array and delete elements one by one
Arguments:
[in] pArray - pointer to an array
Return Value:
None.
--*/
{
// local variables
__PTITEM pItem = NULL;
__PTITEM pNextItem = NULL;
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// traverse thru the list and delete elements one by one
pItem = pArrayEx->pStart;
while ( NULL != pItem )
{
pNextItem = pItem->pNext; // get the next item in the list
__DynArrayFreeItemValue( pItem ); // free memory allocated for data
FreeMemory( &pItem ); // now free the memory allocated for the current item
pItem = pNextItem; // make the previously fetched next item as the current item
}
// as all the items are removed, reset the contents
pArrayEx->dwCount = 0;
pArrayEx->pStart = NULL;
pArrayEx->pLast = NULL;
// return
return;
}
VOID
DestroyDynamicArray(
PTARRAY pArray
)
/*++
Routine Description:
Destory the Dynamic array and free the memory.
Arguments:
[in] pArray - Pointer to the Dynamic array.
Return Value:
none.
--*/
{
// check whether the array is valid or not
if ( FALSE == IsValidArray( *pArray ) )
{
return;
}
// remove all the elements in the array
DynArrayRemoveAll( *pArray );
// now free the memory allocated
FreeMemory( pArray );
}
LONG
DynArrayAppend(
TARRAY pArray,
LPVOID pValue
)
/*++
Routine Description:
To append any type of item into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] pValue - pointer to the Item.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// validate the pointer value
if ( NULL == pValue )
{
return -1; // invalid memory address passed
}
// append the value and return the result
return __DynArrayAppend( pArray, DA_TYPE_GENERAL, sizeof( LPVOID ), pValue );
}
LONG
DynArrayAppendString(
TARRAY pArray,
LPCWSTR szValue,
DWORD dwLength
)
/*++
// ***************************************************************************
Routine Description:
To append a string into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] szValue - pointer to the string
[ in ] dwLength - Length of the String to be passed.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
LPWSTR pszValue = NULL;
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// determine the length of string ( memory ) that has to be allocated
if ( 0 == dwLength )
{
dwLength = lstrlen( szValue );
}
// accomodate space for storing NULL character
dwLength += 1;
// allocate memory for value and check the result of memory allocation
pszValue = ( LPWSTR ) AllocateMemory( dwLength * sizeof( WCHAR ) );
if ( NULL == pszValue )
{
return -1;
}
// copy the contents of the string ( copy should be based on the length )
StringCopy( pszValue, szValue, dwLength );
// now add this item to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_STRING, dwLength * sizeof( WCHAR ), pszValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pszValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendLong(
TARRAY pArray,
LONG lValue
)
/*++
Routine Description:
To append a variable of type Long into the Dynamic Array.
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] lValue - Variable to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
PLONG plValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
plValue = ( LONG* ) AllocateMemory( sizeof( LONG ) );
if ( NULL == plValue )
{
return -1;
}
// set the value
*plValue = lValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_LONG, sizeof( LONG ), plValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &plValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendDWORD(
TARRAY pArray,
DWORD dwValue
)
/*++
Routine Description:
To append a variable of type DWORD into the Dynamic Array.
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dwValue - DWORD type Variable to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
PDWORD pdwValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pdwValue = ( DWORD* ) AllocateMemory( sizeof( DWORD ) );
if ( NULL == pdwValue )
{
return -1;
}
// set the value
*pdwValue = dwValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_DWORD, sizeof( DWORD ), pdwValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pdwValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendBOOL(
TARRAY pArray,
BOOL bValue
)
/*++
Routine Description:
To append a variable of type BOOL into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] bValue - BOOL type Variable to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
PBOOL pbValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pbValue = ( PBOOL ) AllocateMemory( sizeof( BOOL ) );
if ( NULL == pbValue )
{
return -1;
}
// set the value
*pbValue = bValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_BOOL, sizeof( BOOL ), pbValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pbValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendFloat(
TARRAY pArray,
float fValue
)
/*++
Routine Description:
To append a variable of type Float into the Dynamic Array.
Arguments:
[ in ] pArray - Dynamic Array containing the result.
[ in ] fValue - Float type Variable to be appended.
Return Value:
If successfully added the item to the list then return index else -1.
--*/
{
// local variables
LONG lIndex = -1;
float* pfValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pfValue = ( float* ) AllocateMemory( sizeof( float ) );
if ( NULL == pfValue )
{
return -1;
}
// set the value
*pfValue = fValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_FLOAT, sizeof( float ), pfValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pfValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendDouble(
TARRAY pArray,
double dblValue
)
/*++
Routine Description:
To append a variable of type Double into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] dblValue - Double type Variable to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
double* pdblValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pdblValue = ( double* ) AllocateMemory( sizeof( double ) );
if ( NULL == pdblValue )
{
return -1;
}
// set the value
*pdblValue = dblValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_DOUBLE, sizeof( double ), pdblValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pdblValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendHandle(
TARRAY pArray,
HANDLE hValue
)
/*++
Routine Description:
To append a variable of type HANDLE into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] hValue - HANDLE to be appended.
Return Value:
If successfully added the item to the list then return index else -1.
--*/
{
// local variables
LONG lIndex = -1;
HANDLE* phValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
phValue = ( HANDLE* ) AllocateMemory( sizeof( HANDLE ) );
if ( NULL == phValue )
{
return -1;
}
// set the value
*phValue = hValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_HANDLE, sizeof( HANDLE ), phValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( ( LPVOID * )&phValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendFileTime(
TARRAY pArray,
FILETIME ftValue
)
/*++
Routine Description:
To append a variable of type FILETIME into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] ftValue - FILETIME to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
FILETIME* pftValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pftValue = ( FILETIME* ) AllocateMemory( sizeof( FILETIME ) );
if ( NULL == pftValue )
{
return -1;
}
// set the value
*pftValue = ftValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_FILETIME, sizeof( FILETIME ), pftValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pftValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendSystemTime(
TARRAY pArray,
SYSTEMTIME stValue
)
/*++
Routine Description:
To append a variable of type SYSTEMTIME into the Dynamic Array
Arguments:
[ in ] pArray - Dynamic Array containing the result
[ in ] stValue - variable of type SYSTEMTIME to be appended.
Return Value:
If successfully added the item to the list then return index else -1
--*/
{
// local variables
LONG lIndex = -1;
SYSTEMTIME* pstValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pstValue = ( SYSTEMTIME* ) AllocateMemory( sizeof( SYSTEMTIME ) );
if ( NULL == pstValue )
{
return -1;
}
// set the value
*pstValue = stValue;
// now add this item value to the array
lIndex = __DynArrayAppend( pArray, DA_TYPE_SYSTEMTIME, sizeof( SYSTEMTIME ), pstValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pstValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayAppendRow(
TARRAY pArray,
DWORD dwColumns
)
/*++
Routine Description:
To add a empty Row to the 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwColumns - No of columns the Row contains.
Return Value:
return the row number of the newly added row if successful else -1.
--*/
{
// local variables
DWORD dw = 0;
LONG lIndex = -1;
TARRAY arrSubArray = NULL;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// create the dynamic array
arrSubArray = CreateDynamicArray();
if ( FALSE == IsValidArray( arrSubArray ) )
{
return -1; // failed in creating the dynamic array
}
// add the required no. of columns to the sub array
for( dw = 0; dw < dwColumns; dw++ )
{
// add the dummy item to the array and check the result
// if operation failed, break
if ( -1 == __DynArrayAppend( arrSubArray, _TYPE_NEEDINIT, 0, NULL ) )
{
break;
}
}
// check whether the operation is successfull or not
if ( dw != dwColumns )
{
// adding of columns failed
// destroy the dynamic array and return
DestroyDynamicArray( &arrSubArray );
return -1;
}
// now add this sub array to the main array and check the result
lIndex = __DynArrayAppend( pArray, DA_TYPE_ARRAY, sizeof( TARRAY ), arrSubArray );
if ( -1 == lIndex )
{
// failed in attaching the sub array to the main array
// destroy the dynamic array and return failure
DestroyDynamicArray( &arrSubArray );
return -1;
}
// operation is successfull
return lIndex;
}
LONG
DynArrayAddColumns(
TARRAY pArray,
DWORD dwColumns
)
/*++
Routine Description:
To add 'n' no. of columns to the array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwColumns - No of columns the Row contains.
Return Value:
returns the no. of columns added
--*/
{
// local variables
DWORD dw = 0;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// add the required no. of columns to the sub array
for( dw = 0; dw < dwColumns; dw++ )
{
// add the dummy item to the array and check the result
// if operation failed, break
if ( -1 == __DynArrayAppend( pArray, _TYPE_NEEDINIT, 0, NULL ) )
{
break;
}
}
// finish ...
return dw;
}
LONG
DynArrayInsertColumns(
TARRAY pArray,
DWORD dwIndex,
DWORD dwColumns
)
/*++
Routine Description:
inserts 'n' no. of columns to the array at the n'th location
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwColumns - No of columns the Row contains.
Return Value:
returns the no. of columns added
--*/
{
// local variables
DWORD dw = 0;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// add the required no. of columns to the sub array
for( dw = 0; dw < dwColumns; dw++ )
{
// add the dummy item to the array and check the result
// if operation failed, break
if ( -1 == __DynArrayInsert( pArray, dwIndex, _TYPE_NEEDINIT, 0, NULL ) )
{
break;
}
}
// finish ...
return dw;
}
LONG
DynArrayAppend2(
TARRAY pArray,
DWORD dwRow,
LPVOID pValue
)
/*++
Routine Description:
To append a variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] pValue - pointer to the value
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArrayAppend( pItem->pValue, pValue );
}
LONG
DynArrayAppendString2(
TARRAY pArray,
DWORD dwRow,
LPCWSTR szValue,
DWORD dwLength
)
/*++
Routine Description:
To append a string variable to a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] szValue - pointer to the string value
[ in ] dwLength - length of the string.
Return Value:
LONG value on success -1 on failure.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendString( pItem->pValue, szValue, dwLength );
}
LONG
DynArrayAppendLong2(
TARRAY pArray,
DWORD dwRow,
LONG lValue
)
/*++
Routine Description:
To append a long type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] lValue - long type value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendLong( pItem->pValue, lValue );
}
LONG
DynArrayAppendDWORD2(
TARRAY pArray,
DWORD dwRow,
DWORD dwValue
)
/*++
Routine Description:
To append a DWORD type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] dwValue - DWORD type value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendDWORD( pItem->pValue, dwValue );
}
LONG
DynArrayAppendBOOL2(
TARRAY pArray,
DWORD dwRow,
BOOL bValue
)
/*++
Routine Description:
To append a BOOL type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] bValue - BOOL type value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendBOOL( pItem->pValue, bValue );
}
LONG
DynArrayAppendFloat2(
TARRAY pArray,
DWORD dwRow,
float fValue
)
/*++
Routine Description:
To append a Float type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] fValue - Float type value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendFloat( pItem->pValue, fValue );
}
LONG
DynArrayAppendDouble2(
TARRAY pArray,
DWORD dwRow,
double dblValue
)
/*++
Routine Description:
To append a double type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] dblValue - dblValue type value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendDouble( pItem->pValue, dblValue );
}
LONG
DynArrayAppendHandle2(
TARRAY pArray,
DWORD dwRow,
HANDLE hValue
)
/*++
Routine Description:
To append a Handle type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] hValue - Handle value to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendHandle( pItem->pValue, hValue );
}
LONG
DynArrayAppendFileTime2(
TARRAY pArray,
DWORD dwRow,
FILETIME ftValue
)
/*++
Routine Description:
To append a FILETIME type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] ftValue - variable of type FILETIME to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendFileTime( pItem->pValue, ftValue );
}
LONG
DynArrayAppendSystemTime2(
TARRAY pArray,
DWORD dwRow,
SYSTEMTIME stValue
)
/*++
Routine Description:
To append a SYSTEMTIME type variable to a row in a 2-dimensional Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row posn for which the new value
is to be added.
[ in ] stValue - variable of type SYSTEMTIME to be appended.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayAppendSystemTime( pItem->pValue, stValue );
}
LONG
DynArrayInsert(
TARRAY pArray,
DWORD dwIndex,
LPVOID pValue
)
/*++
Routine Description:
To insert a variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] pValue - value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// validate the pointer value
if ( NULL == pValue )
{
return -1; // invalid memory address passed
}
// append the value and return the result
return __DynArrayInsert( pArray, dwIndex, DA_TYPE_GENERAL, sizeof( LPVOID ), pValue );
}
LONG
DynArrayInsertString(
TARRAY pArray,
DWORD dwIndex,
LPCWSTR szValue,
DWORD dwLength
)
/*++
Routine Description:
To insert a string type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] szValue - pointer to the string
[ in ] dwLength - length of the string.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
LPWSTR pszValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// determine the length of string ( memory ) that has to be allocated
if ( 0 == dwLength )
{
dwLength = lstrlen( szValue );
}
// accomodate space for storing NULL character
dwLength += 1;
// allocate memory for and check the result of memory allocation
pszValue = ( LPWSTR ) AllocateMemory( dwLength * sizeof( WCHAR ) );
if ( NULL == pszValue )
{
return -1;
}
// copy the contents of the string ( copy should be based on the length )
StringCopy( pszValue, szValue, dwLength );
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex,
DA_TYPE_STRING, dwLength * sizeof( WCHAR ), pszValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pszValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertLong(
TARRAY pArray,
DWORD dwIndex,
LONG lValue
)
/*++
Routine Description:
To insert a string type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] lValue - pointer to the string.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
PLONG plValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
plValue = ( LONG* ) AllocateMemory( sizeof( LONG ) );
if ( NULL == plValue )
{
return -1;
}
// set the value
*plValue = lValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_LONG, sizeof( LONG ), plValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &plValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertDWORD(
TARRAY pArray,
DWORD dwIndex,
DWORD dwValue
)
/*++
Routine Description:
To insert a DWORD type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] dwValue - specifies the variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
PDWORD pdwValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pdwValue = ( PDWORD ) AllocateMemory( sizeof( DWORD ) );
if ( NULL == pdwValue )
{
return -1;
}
// set the value
*pdwValue = dwValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_DWORD, sizeof( DWORD ), pdwValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pdwValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertBOOL(
TARRAY pArray,
DWORD dwIndex,
BOOL bValue
)
/*++
Routine Description:
To insert a BOOL type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] bValue - specifies the BOOL variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
PBOOL pbValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pbValue = ( PBOOL ) AllocateMemory( sizeof( BOOL ) );
if ( NULL == pbValue )
{
return -1;
}
// set the value
*pbValue = bValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_BOOL, sizeof( BOOL ), pbValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pbValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertFloat(
TARRAY pArray,
DWORD dwIndex,
float fValue
)
/*++
Routine Description:
To insert a float type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] fValue - specifies the float type variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
float* pfValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pfValue = ( float* ) AllocateMemory( sizeof( float ) );
if ( NULL == pfValue )
{
return -1;
}
// set the value
*pfValue = fValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_FLOAT, sizeof( float ), pfValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pfValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertDouble(
TARRAY pArray,
DWORD dwIndex,
double dblValue
)
/*++
Routine Description:
To insert a double type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] dblValue - specifies the double type variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
double* pdblValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pdblValue = ( double* ) AllocateMemory( sizeof( double ) );
if ( NULL == pdblValue )
{
return -1;
}
// set the value
*pdblValue = dblValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_DOUBLE, sizeof( double ), pdblValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pdblValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertHandle(
TARRAY pArray,
DWORD dwIndex,
HANDLE hValue
)
/*++
Routine Description:
To insert a HANDLE type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] hValue - specifies the HANDLE type variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
HANDLE* phValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
phValue = ( HANDLE* ) AllocateMemory( sizeof( HANDLE ) );
if ( NULL == phValue )
{
return -1;
}
// set the value
*phValue = hValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_HANDLE, sizeof( HANDLE ), phValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( (LPVOID * )&phValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertSystemTime(
TARRAY pArray,
DWORD dwIndex,
SYSTEMTIME stValue
)
/*++
Routine Description:
To insert a SYSTEMTIME type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] stValue - specifies the SYSTEMTIME type variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
SYSTEMTIME* pstValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pstValue = ( SYSTEMTIME* ) AllocateMemory( sizeof( SYSTEMTIME ) );
if ( NULL == pstValue )
{
return -1;
}
// set the value
*pstValue = stValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_SYSTEMTIME,
sizeof( SYSTEMTIME ), pstValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pstValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertFileTime(
TARRAY pArray,
DWORD dwIndex,
FILETIME ftValue
)
/*++
Routine Description:
To insert a SYSTEMTIME type variable into a Dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] ftValue - specifies the SYSTEMTIME type variable to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
LONG lIndex = -1;
FILETIME* pftValue = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return -1;
}
// allocate memory for value and check the result of memory allocation
pftValue = ( FILETIME* ) AllocateMemory( sizeof( FILETIME ) );
if ( NULL == pftValue )
{
return -1;
}
// set the value
*pftValue = ftValue;
// now add this item value to the array
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_FILETIME,
sizeof( FILETIME ), pftValue );
if ( -1 == lIndex )
{
// failed in adding this item to the array
// so, free the memory allocated and return from the function
FreeMemory( &pftValue );
return -1;
}
// added the item to the array
return lIndex;
}
LONG
DynArrayInsertRow(
TARRAY pArray,
DWORD dwIndex,
DWORD dwColumns
)
/*++
Routine Description:
this funtion insert a new row to a dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - Specifies the index.
[ in ] dwColumns - specifies the number of columns to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
DWORD dw = 0;
LONG lIndex = -1;
TARRAY arrSubArray = NULL;
// validate the array
if ( FALSE == IsValidArray( pArray ) )
{
return -1; // array is not valid
}
// create the dynamic array
arrSubArray = CreateDynamicArray();
if ( FALSE == IsValidArray( arrSubArray ) )
{
return -1; // failed in creating the dynamic array
}
// add the required no. of columns to the sub array
for( dw = 0; dw < dwColumns; dw++ )
{
// add the dummy item to the array and check the result
// if operation failed, break
if ( -1 == __DynArrayAppend( arrSubArray, _TYPE_NEEDINIT, 0, NULL ) )
{
break;
}
}
// check whether the operation is successfull or not
if ( dw != dwColumns )
{
// adding of columns failed
// destroy the dynamic array and return
DestroyDynamicArray( &arrSubArray );
return -1;
}
// now add this sub array to the main array and check the result
lIndex = __DynArrayInsert( pArray, dwIndex, DA_TYPE_ARRAY,
sizeof( TARRAY ), arrSubArray );
if ( -1 == lIndex )
{
// failed in attaching the sub array to the main array
// destroy the dynamic array and return failure
DestroyDynamicArray( &arrSubArray );
return -1;
}
// operation is successfull
return lIndex;
}
LONG
DynArrayInsert2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
LPVOID pValue
)
/*++
Routine Description:
this funtion insert a new row to a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] pValue - pointer to the value.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArrayInsert( pItem->pValue, dwColIndex, pValue );
}
LONG
DynArrayInsertString2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
LPCWSTR szValue,
DWORD dwLength
)
/*++
Routine Description:
this funtion insert a new string into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] szValue - pointer to the value.
[ in ] dwLength - string length.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertString( pItem->pValue, dwColIndex, szValue, dwLength );
}
LONG
DynArrayInsertLong2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
LONG lValue
)
/*++
Routine Description:
this funtion insert a new long type varaible into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] lValue - long type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertLong( pItem->pValue, dwColIndex, lValue );
}
LONG
DynArrayInsertDWORD2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
DWORD dwValue
)
/*++
Routine Description:
this funtion insert a new DWORD type varaible into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] dwValue - DWORD value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertDWORD( pItem->pValue, dwColIndex, dwValue );
}
LONG
DynArrayInsertBOOL2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
BOOL bValue
)
/*++
Routine Description:
this funtion insert a new BOOL type variable into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] bValue - BOOL type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertBOOL( pItem->pValue, dwColIndex, bValue );
}
LONG
DynArrayInsertFloat2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
float fValue
)
/*++
Routine Description:
this funtion insert a new float type variable into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] fValue - float type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertFloat( pItem->pValue, dwColIndex, fValue );
}
LONG
DynArrayInsertDouble2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
double dblValue
)
/*++
Routine Description:
this funtion insert a new double type variable into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] dblValue - double type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertDouble( pItem->pValue, dwColIndex, dblValue );
}
LONG
DynArrayInsertHandle2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
HANDLE hValue
)
/*++
Routine Description:
this funtion insert a new double type variable into a 2-dimensional dynamic array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] hValue - HANDLE type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertHandle( pItem->pValue, dwColIndex, hValue );
}
LONG
DynArrayInsertSystemTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
SYSTEMTIME stValue
)
/*++
Routine Description:
This funtion insert a new SYSTEMTIME type variable into a 2-dimensional dynamic array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] stValue - SYSTEMTIME type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertSystemTime( pItem->pValue, dwColIndex, stValue );
}
LONG
DynArrayInsertFileTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
FILETIME ftValue
)
/*++
Routine Description:
this funtion insert a new FILETIME type variable into a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - Specifies the row.
[ in ] dwColIndex - specifies the column
[ in ] ftValue - FILETIME type value to be inserted.
Return Value:
-1 on failure
index in the case of success.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayInsertFileTime( pItem->pValue, dwColIndex, ftValue );
}
BOOL
DynArrayRemove(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
This funtion empties the contents of the dynamic array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - specifies the column
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
__PTITEM pPrevItem = NULL;
__PTARRAY pArrayEx = NULL;
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// get the pointer to the item that has to be removed and also its previous item
pItem = __DynArrayGetItem( pArrayEx, dwIndex, &pPrevItem );
if ( NULL == pItem )
{
return FALSE; // index or array is invalid ... cannot proceed
}
// unlink the item from the list first
// before unlinking, check whether item which is going to deleted
// is the first item in the list
// is the last item in the list
// is the middle item in the list
// Control should not come here if no items are present in the ARRAY.
// If middle item or last item.
if ( pPrevItem != NULL ) { pPrevItem->pNext = pItem->pNext; }
// If first item of the array.
if ( pPrevItem == NULL ) { pArrayEx->pStart = pItem->pNext; }
// If last item of the array.
if ( pItem == pArrayEx->pLast ) { pArrayEx->pLast = pPrevItem; }
// update the count of the array item
pArrayEx->dwCount--;
// free the memory being used by the currently unlinked item and return success
__DynArrayFreeItemValue( pItem ); // free the memory allocated for storing data
FreeMemory( &pItem ); // finally free the memory allocated for item itself
return TRUE;
}
BOOL
DynArrayRemoveColumn(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this funtion REMOVES a column from a dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - specifies the row.
[ in ] dwColumn - specifies the column
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayRemove( pItem->pValue, dwColumn );
}
DWORD
DynArrayGetCount(
TARRAY pArray
)
/*++
Routine Description:
this function retreives the number of rows in a 1-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTARRAY pArrayEx = NULL;
// check whether the array is valid or not
if ( FALSE == IsValidArray( pArray ) )
{
return 0;
}
// convert the passed memory location info into appropriate structure
pArrayEx = ( __PTARRAY ) pArray;
// return the size of the array
return pArrayEx->dwCount;
}
DWORD
DynArrayGetCount2(
TARRAY pArray,
DWORD dwRow
)
/*++
Routine Description:
this function retreives the number of columns in a 2-dimensional dynamic array
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row for which the number of columns have to be got.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayGetCount( pItem->pValue );
}
LPVOID
DynArrayItem(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return NULL; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_GENERAL != pItem->dwType && DA_TYPE_ARRAY != pItem->dwType )
{
return NULL;
}
// now return the contents of the __TITEM structure
return pItem->pValue;
}
LPCWSTR
DynArrayItemAsString(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a string.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return NULL; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_STRING != pItem->dwType )
{
return NULL;
}
// now return the contents of the __TITEM structure
return ( ( LPCWSTR ) pItem->pValue );
}
LONG
DynArrayItemAsLong(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a Long varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return -1; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_DWORD != pItem->dwType && DA_TYPE_LONG != pItem->dwType )
{
return -1;
}
// now return the contents of the __TITEM structure
return ( *( PLONG ) pItem->pValue );
}
DWORD
DynArrayItemAsDWORD(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a DWORD varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return 0; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_DWORD != pItem->dwType && DA_TYPE_LONG != pItem->dwType )
{
return 0;
}
// now return the contents of the __TITEM structure
return *( ( PDWORD ) pItem->pValue );
}
BOOL
DynArrayItemAsBOOL(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a bool type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_BOOL != pItem->dwType )
{
return FALSE;
}
// now return the contents of the __TITEM structure
return *( ( PBOOL ) pItem->pValue );
}
float
DynArrayItemAsFloat(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a float type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return -1.0f; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_FLOAT != pItem->dwType )
{
return -1.0f;
}
// now return the contents of the __TITEM structure
return *( ( float* ) pItem->pValue );
}
double
DynArrayItemAsDouble(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a double type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return -1.0; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_DOUBLE != pItem->dwType )
{
return -1.0;
}
// now return the contents of the __TITEM structure
return *( ( double* ) pItem->pValue );
}
HANDLE
DynArrayItemAsHandle(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
This function retreives the item from a dynamic array as a handle type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return NULL; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_HANDLE != pItem->dwType )
{
return NULL;
}
// now return the contents of the __TITEM structure
return *( ( HANDLE* ) pItem->pValue );
}
SYSTEMTIME
DynArrayItemAsSystemTime(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a SYSTEMTIME type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
FILETIME ftTemp;
SYSTEMTIME stTemp; // dummy
ZeroMemory( &ftTemp, sizeof( FILETIME ) );
ZeroMemory( &stTemp, sizeof( SYSTEMTIME ) );
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return stTemp; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_SYSTEMTIME != pItem->dwType && DA_TYPE_FILETIME != pItem->dwType )
{
return stTemp;
}
// now do the needed manipulations ( if needed )
if ( pItem->dwType == DA_TYPE_SYSTEMTIME )
{
// value itself is of required type
stTemp = *( ( SYSTEMTIME* ) pItem->pValue );
}
else
{
// need to do conversions
ftTemp = *( ( FILETIME* ) pItem->pValue );
// Intentionally return value is not checked.
FileTimeToSystemTime( &ftTemp, &stTemp );
}
// now return the contents of the __TITEM structure
return stTemp;
}
FILETIME
DynArrayItemAsFileTime(
TARRAY pArray,
DWORD dwIndex
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a FILETIME type varaible.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
FILETIME ftTemp; // dummy
SYSTEMTIME stTemp; // dummy
ZeroMemory( &ftTemp, sizeof( FILETIME ) );
ZeroMemory( &stTemp, sizeof( SYSTEMTIME ) );
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return ftTemp; // index / array is not valid
}
// check the type of the item first
// if the type doesn't match, return some default value
if ( DA_TYPE_SYSTEMTIME != pItem->dwType && DA_TYPE_FILETIME != pItem->dwType )
{
return ftTemp;
}
// now do the needed manipulations ( if needed )
if ( DA_TYPE_FILETIME == pItem->dwType )
{
// value itself is of required type
ftTemp = *( ( FILETIME* ) pItem->pValue );
}
else
{
// need to do conversions
stTemp = *( ( SYSTEMTIME* ) pItem->pValue );
// Intentionally return value is not checked.
SystemTimeToFileTime( &stTemp, &ftTemp );
}
// now return the contents of the __TITEM structure
return ftTemp;
}
DWORD
DynArrayItemAsStringEx(
TARRAY pArray,
DWORD dwIndex,
LPWSTR szBuffer,
DWORD dwLength
)
/*++
Routine Description:
this function retreives the item from a dynamic array in string format.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - index.
[ in ] szBuffer - buffer to hold the string
[ in ] dwlength - string length.
Return Value:
false on failure
true ON SUCCESS.
--*/
{
// local variables
__PTITEM pItem = NULL;
__MAX_SIZE_STRING szTemp = NULL_STRING;
// check the length specified
if ( 0 == dwLength )
{
return 0;
}
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return 0; // index / array is not valid
}
// give the value based on the type of the current item
StringCopy( szBuffer, NULL_STRING, dwLength ); // clear the existing contents
// convert and get the values in string format
switch( pItem->dwType )
{
case DA_TYPE_STRING:
StringCopy( szBuffer, ( LPCWSTR ) pItem->pValue, dwLength );
break;
case DA_TYPE_LONG:
//FORMAT_STRING( szTemp, _T( "%ld" ), *( LONG* ) pItem->pValue );
StringCchPrintfW( szTemp, MAX_STRING_LENGTH, _T( "%ld" ), *( LONG* ) pItem->pValue );
StringCopy( szBuffer, szTemp, dwLength );
break;
case DA_TYPE_DWORD:
//FORMAT_STRING( szTemp, _T( "%lu" ), *( DWORD* ) pItem->pValue );
StringCchPrintfW( szTemp, MAX_STRING_LENGTH, _T( "%lu" ), *( DWORD* ) pItem->pValue );
StringCopy( szBuffer, szTemp, dwLength );
break;
case DA_TYPE_FLOAT:
//FORMAT_STRING( szTemp, _T( "%f" ), *( float* ) pItem->pValue );
StringCchPrintfW( szTemp, MAX_STRING_LENGTH, _T( "%f" ), *( float* ) pItem->pValue );
StringCopy( szBuffer, szTemp, dwLength );
break;
case DA_TYPE_DOUBLE:
//FORMAT_STRING( szTemp, _T( "%f" ), *( double* ) pItem->pValue );
StringCchPrintfW( szTemp, MAX_STRING_LENGTH, _T( "%f" ), *( double* ) pItem->pValue );
StringCopy( szBuffer, szTemp, dwLength );
break;
case DA_TYPE_BOOL:
case DA_TYPE_ARRAY:
case DA_TYPE_HANDLE:
case DA_TYPE_SYSTEMTIME:
case DA_TYPE_FILETIME:
case DA_TYPE_GENERAL:
case _TYPE_NEEDINIT:
default:
break; // no value can be set
}
// return
return lstrlen( szBuffer );
}
LPVOID
DynArrayItem2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
This function retreives the item from a 2-dimensional dynamic array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - The number of rows
[ in ] dwColumn - The number of columns
Return Value:
pointer to the item.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return NULL; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItem( pItem->pValue, dwColumn );
}
LPCWSTR
DynArrayItemAsString2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a string.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
pointer to the the constant string.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return NULL; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsString( pItem->pValue, dwColumn );
}
LONG
DynArrayItemAsLong2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a long variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type Long
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsLong( pItem->pValue, dwColumn );
}
DWORD
DynArrayItemAsDWORD2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
This function retreives the item from a dynamic array as a DWORD variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type DWORD
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return 0; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsDWORD( pItem->pValue, dwColumn );
}
BOOL
DynArrayItemAsBOOL2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
This function retreives the item from a dynamic array as a BOOL variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type BOOL.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsBOOL( pItem->pValue, dwColumn );
}
float
DynArrayItemAsFloat2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a float variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type float.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1.0f; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsFloat( pItem->pValue, dwColumn );
}
double
DynArrayItemAsDouble2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a double variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type double.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1.0; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsDouble( pItem->pValue, dwColumn );
}
HANDLE
DynArrayItemAsHandle2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
This function retreives the item from a dynamic array as a HANDLE variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type HANDLE.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return NULL; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsHandle( pItem->pValue, dwColumn );
}
SYSTEMTIME
DynArrayItemAsSystemTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a dynamic array as a SYSTEMTIME type variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type SYSTEMTIME.
--*/
{
// local variables
__PTITEM pItem = NULL;
SYSTEMTIME stTemp; // dummy
ZeroMemory( &stTemp, sizeof( SYSTEMTIME ) );
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return stTemp; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsSystemTime( pItem->pValue, dwColumn );
}
DWORD
DynArrayItemAsStringEx2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
LPWSTR szBuffer,
DWORD dwLength
)
/*++
Routine Description:
this function retreives the item from a 2 dimensional dynamic array as
a string type variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
[ in ] szBuffer - String buffer
[ in ] dwLength - length of the string.
Return Value:
TRUE on success.
FALSE on failure.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return 0; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsStringEx( pItem->pValue, dwColumn, szBuffer, dwLength );
}
FILETIME
DynArrayItemAsFileTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
Routine Description:
this function retreives the item from a 2 dimensional dynamic array as
a FILETIME type variable.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwRow - row .
[ in ] dwColumn - column
Return Value:
The variable of type FILETIME.
--*/
{
// local variables
__PTITEM pItem = NULL;
FILETIME ftTemp; // dummy
ZeroMemory( &ftTemp, sizeof( FILETIME ) );
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return ftTemp; // no item exists at the specified row or item is not of type array
}
// now add the string to the sub array and return the result to the caller
return DynArrayItemAsFileTime( pItem->pValue, dwColumn );
}
BOOL
DynArraySet(
TARRAY pArray,
DWORD dwIndex,
LPVOID pValue
)
/*++
Routine Description:
general function which inserts an item into a 1-dimensional array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - row .
[ in ] pValue - column
Return Value:
TRUE : if successfully inserted the item into the array.
FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// validate the pointer value
if ( NULL == pValue )
{
return FALSE; // invalid memory address passed
}
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ... it should of string type
if ( DA_TYPE_GENERAL != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if the item is being initialized now ... change the type
if ( _TYPE_NEEDINIT == pItem->dwType )
{
pItem->dwType = DA_TYPE_GENERAL;
}
// set the value of the current item
pItem->pValue = pValue;
// return the result
return TRUE;
}
BOOL
DynArraySetString(
TARRAY pArray,
DWORD dwIndex,
LPCWSTR szValue,
DWORD dwLength
)
/*++
// Routine Description:
// This function inserts an string variable into a 1-dimensional array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] szValue - string to be inserted.
// [ in ] dwLength - length of the string to be insertes
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_STRING != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// determine the length of string ( memory ) that has to be allocated
if ( 0 == dwLength )
{
dwLength = lstrlen( szValue );
}
// accomodate space for storing NULL character
dwLength += 1;
// memory has to adjusted based on the exisiting memory size and new contents size
// before that, we need to check whether the current is initialized or not
// if not yet initialized, we have to initialize it now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// memory has to be initialized now
pItem->pValue = AllocateMemory( dwLength * sizeof( WCHAR ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in allocation
}
// set the type and size information
pItem->dwType = DA_TYPE_STRING;
pItem->dwSize = dwLength * sizeof( WCHAR );
}
else
{
if ( pItem->dwSize < dwLength * sizeof( WCHAR ) )
{
// release the existing memory pointer/location
FreeMemory( &( pItem->pValue ) );
// now allocate the needed memory
pItem->pValue = NULL;
pItem->pValue = AllocateMemory( dwLength * sizeof( WCHAR ) );
if ( NULL == pItem->pValue )
{
// failed in re-allocation
return FALSE;
}
// update the size of the buffer
pItem->dwSize = dwLength * sizeof( WCHAR );
}
}
// copy the contents of the string ( copy should be based on the length )
StringCopy( ( LPWSTR ) pItem->pValue, szValue, dwLength );
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetLong(
TARRAY pArray,
DWORD dwIndex,
LONG lValue
)
/*++
// Routine Description:
// This function inserts an long type variable into a 1-dimensional array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] lValue - long value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_LONG != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( LONG ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_LONG;
pItem->dwSize = sizeof( LONG );
}
// set the new value
*( ( LONG* ) pItem->pValue ) = lValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetDWORD(
TARRAY pArray,
DWORD dwIndex,
DWORD dwValue
)
/*++
Routine Description:
This function inserts an DWORD type variable into a 1-dimensional array.
Arguments:
[ in ] pArray - Dynamic Array
[ in ] dwIndex - position .
[ in ] dwValue - DWORD value to be inserted.
Return Value:
TRUE : if successfully inserted the item into the array.
FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_DWORD != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( DWORD ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_DWORD;
pItem->dwSize = sizeof( DWORD );
}
// set the new value
*( ( DWORD* ) pItem->pValue ) = dwValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetBOOL(
TARRAY pArray,
DWORD dwIndex,
BOOL bValue
)
/*++
// Routine Description:
// This function inserts an BOOL type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] bValue - BOOL value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_BOOL != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( BOOL ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_BOOL;
pItem->dwSize = sizeof( DWORD );
}
// set the new value
*( ( BOOL* ) pItem->pValue ) = bValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetFloat(
TARRAY pArray,
DWORD dwIndex,
float fValue
)
/*++
// Routine Description:
// This function inserts an Float type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] fValue - float type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_FLOAT != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( float ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_FLOAT;
pItem->dwSize = sizeof( float );
}
// set the new value
*( ( float* ) pItem->pValue ) = fValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetDouble(
TARRAY pArray,
DWORD dwIndex,
double dblValue
)
/*++
// Routine Description:
// This function inserts an double type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] dblValue - double type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
//
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_DOUBLE != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( double ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_DOUBLE;
pItem->dwSize = sizeof( double );
}
// set the new value
*( ( double* ) pItem->pValue ) = dblValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetHandle(
TARRAY pArray,
DWORD dwIndex,
HANDLE hValue
)
/*++
// Routine Description:
// This function inserts an Handle type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] hValue - Handle type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_HANDLE != pItem->dwType && _TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( pItem->dwType == _TYPE_NEEDINIT )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( HANDLE ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_HANDLE;
pItem->dwSize = sizeof( HANDLE );
}
// set the new value
*( ( HANDLE* ) pItem->pValue ) = hValue;
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetSystemTime(
TARRAY pArray,
DWORD dwIndex,
SYSTEMTIME stValue
)
/*++
// Routine Description:
// This function inserts an SYSTEMTIME type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] stValue - SYSTEMTIME type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
FILETIME ftTemp; // dummy
ZeroMemory( &ftTemp, sizeof( FILETIME ) );
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_SYSTEMTIME != pItem->dwType &&
DA_TYPE_FILETIME != pItem->dwType &&
_TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( SYSTEMTIME ) );
if ( NULL == pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_SYSTEMTIME;
pItem->dwSize = sizeof( SYSTEMTIME );
}
// depending on the type set the value
if ( DA_TYPE_FILETIME == pItem->dwType )
{
// do the needed conversions and then set
SystemTimeToFileTime( &stValue, &ftTemp );
*( ( FILETIME* ) pItem->pValue ) = ftTemp;
}
else
{
// set the new value as it is
*( ( SYSTEMTIME* ) pItem->pValue ) = stValue;
}
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySetFileTime(
TARRAY pArray,
DWORD dwIndex,
FILETIME ftValue
)
/*++
// Routine Description:
// This function inserts an FILETIME type variable into a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - position .
// [ in ] ftValue - FILETIME type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
SYSTEMTIME stTemp; // dummy
ZeroMemory( &stTemp, sizeof( SYSTEMTIME ) );
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ...
if ( DA_TYPE_FILETIME != pItem->dwType &&
DA_TYPE_SYSTEMTIME != pItem->dwType &&
_TYPE_NEEDINIT != pItem->dwType )
{
return FALSE;
}
// if item is not yet allocated memory, we have to allocate now
if ( _TYPE_NEEDINIT == pItem->dwType )
{
// allocate memory
pItem->pValue = AllocateMemory( sizeof( FILETIME ) );
if ( NULL ==pItem->pValue )
{
return FALSE; // failed in memory allocation
}
// set the type
pItem->dwType = DA_TYPE_FILETIME;
pItem->dwSize = sizeof( FILETIME );
}
// depending on the type set the value
if ( DA_TYPE_SYSTEMTIME ==pItem->dwType )
{
// do the needed conversions and then set
FileTimeToSystemTime( &ftValue, &stTemp );
*( ( SYSTEMTIME* ) pItem->pValue ) = stTemp;
}
else
{
// set the new value as it is
*( ( FILETIME* ) pItem->pValue ) = ftValue;
}
// copied ... value set successfully
return TRUE;
}
BOOL
DynArraySet2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
LPVOID pValue
)
/*++
// Routine Description:
// This function is a general function to insert an variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] pValue - value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySet( pItem->pValue, dwColumn, pValue );
}
BOOL
DynArraySetString2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
LPCWSTR szValue,
DWORD dwLength
)
/*++
// Routine Description:
// This function inserts a string variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] szValue - Pointer to the string
// [ in ] dwlength - length of the string to be inserted
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySetString( pItem->pValue, dwColumn, szValue, dwLength );
}
BOOL
DynArraySetLong2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
LONG lValue
)
/*++
// Routine Description:
// This function inserts a Long variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] lValue - value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySetLong( pItem->pValue, dwColumn, lValue );
}
BOOL
DynArraySetDWORD2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
DWORD dwValue
)
/*++
// Routine Description:
// This function inserts a DWORD variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] dwValue - DWORD value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySetDWORD( pItem->pValue, dwColumn, dwValue );
}
BOOL
DynArraySetBOOL2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
BOOL bValue
)
/*++
// Routine Description:
// This function inserts a BOOL variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] bValue - BOOL value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySetBOOL( pItem->pValue, dwColumn, bValue );
}
BOOL
DynArraySetFloat2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
float fValue
)
/*++
// Routine Description:
// This function inserts a float variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] fValue - float type value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the value to the sub array and return the result to the caller
return DynArraySetFloat( pItem->pValue, dwColumn, fValue );
}
BOOL
DynArraySetDouble2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
double dblValue
)
/*++
// Routine Description:
// This function inserts a Double variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] dblValue - Double type value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the vale to the sub array and return the result to the caller
return DynArraySetDouble( pItem->pValue, dwColumn, dblValue );
}
BOOL
DynArraySetHandle2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
HANDLE hValue
)
/*++
// Routine Description:
// This function inserts a HANDLE variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] hValue - HANDLE type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the vale to the sub array and return the result to the caller
return DynArraySetHandle( pItem->pValue, dwColumn, hValue );
}
BOOL
DynArraySetFileTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
FILETIME ftValue
)
/*++
// Routine Description:
// This function inserts a FILETIME variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] ftValue - FILETIME type value to be inserted.
//
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the vale to the sub array and return the result to the caller
return DynArraySetFileTime( pItem->pValue, dwColumn, ftValue );
}
BOOL
DynArraySetSystemTime2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
SYSTEMTIME stValue
)
/*++
// Routine Description:
// This function inserts a SYSTEMTIME variable into a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwcolumn - column at which the element is to be inserted.
// [ in ] stValue - SYSTEMTIME type value to be inserted.
// Return Value:
// TRUE : if successfully inserted the item into the array.
// FALSE : if Unsuccessfull .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the vale to the sub array and return the result to the caller
return DynArraySetSystemTime( pItem->pValue, dwColumn, stValue );
}
DWORD
DynArrayGetItemType(
TARRAY pArray,
DWORD dwIndex
)
/*++
// Routine Description:
// This function retreives the type of a element in a 1-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - row position .
//
// Return Value:
// the type of array.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return DA_TYPE_NONE; // item not found / invalid array pointer
}
// return the type of the array
return pItem->dwType;
}
DWORD
DynArrayGetItemType2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn
)
/*++
// Routine Description:
// This function retreives the type of a element in a 2-dimensional dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position .
// [ in ] dwColumn - column position
//
// Return Value:
// the type of array.
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return FALSE; // no item exists at the specified row or item is not of type array
}
// now add the vale to the sub array and return the result to the caller
return DynArrayGetItemType( pItem->pValue, dwColumn );
}
LONG
DynArrayFindLong(
TARRAY pArray,
LONG lValue
)
/*++
// Routine Description:
// This function returns the index of the Long variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] lValue - the item to be searched. .
//
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_LONG, &lValue, FALSE, 0 );
}
LONG
DynArrayFindDWORD(
TARRAY pArray,
DWORD dwValue
)
/*++
// Routine Description:
// This function returns the index of the DWORD variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwValue - value to be searched.
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_DWORD, &dwValue, FALSE, 0 );
}
LONG
DynArrayFindFloat(
TARRAY pArray,
float fValue
)
/*++
// Routine Description:
// This function returns the index of the float variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] fValue - the item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_FLOAT, &fValue, FALSE, 0 );
}
LONG
DynArrayFindDouble(
TARRAY pArray,
double dblValue
)
/*++
// Routine Description:
// This function returns the index of the double type variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dblValue - the item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_DOUBLE, &dblValue, FALSE, 0 );
}
LONG
DynArrayFindHandle(
TARRAY pArray,
HANDLE hValue
)
/*++
// Routine Description:
// This function returns the index of the HANDLE type variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] hValue - the HANDLE type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_HANDLE, &hValue, FALSE, 0 );
}
LONG
DynArrayFindString(
TARRAY pArray,
LPCWSTR szValue,
BOOL bIgnoreCase,
DWORD dwCount
)
/*++
// Routine Description:
// This function returns the index of the String type variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array.
// [ in ] szValue - pointer to the string.
// [ in ] bIgnoreCase - boolean indicating if to perform
// case sensitive search or not.
// [ in ] dwCount - string length.
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_STRING, ( LPVOID ) szValue, bIgnoreCase, dwCount );
}
LONG
DynArrayFindSystemTime(
TARRAY pArray,
SYSTEMTIME stValue
)
/*++
// Routine Description:
// This function returns the index of the SYSTEMTIME type variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] stValue - the SYSTEMTIME item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_SYSTEMTIME, &stValue, FALSE, 0 );
}
LONG
DynArrayFindFileTime(
TARRAY pArray,
FILETIME ftValue
)
/*++
// Routine Description:
// This function returns the index of the FILETIME type variable.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] ftValue - the item of type FILETIME to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFind( pArray, DA_TYPE_FILETIME, &ftValue, FALSE, 0 );
}
LONG
DynArrayFindLong2(
TARRAY pArray,
DWORD dwRow,
LONG lValue
)
/*++
// Routine Description:
// This function returns the index of the LONG type variable from a 2-d dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row
// [ in ] lValue - the item of type LONG to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
return -1; // no item exists at the specified row or item is not of type array
// return the value
return DynArrayFindLong( pItem->pValue, lValue );
}
LONG
DynArrayFindDWORD2(
TARRAY pArray,
DWORD dwRow,
DWORD dwValue
)
/*++
// Routine Description:
// This function returns the index of the DWORD type variable from a 2-d dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row
// [ in ] dwValue - the item of type DWORD to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindDWORD( pItem->pValue, dwValue );
}
LONG
DynArrayFindString2(
TARRAY pArray,
DWORD dwRow,
LPCWSTR szValue,
BOOL bIgnoreCase,
DWORD dwCount
)
/*++
// Routine Description:
// This function returns the index of the DWORD type variable from a 2-d dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row
// [ in ] szValue - pointer to the string.
// [ in ] bIgnoreCase - boolean for case sensitive search.
// [ in ] dwCount - string length. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindString( pItem->pValue, szValue, bIgnoreCase, dwCount );
}
LONG
DynArrayFindFloat2(
TARRAY pArray,
DWORD dwRow,
float fValue
)
/*++
// Routine Description:
// This function returns the index of the float type variable from a 2-d dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row
// [ in ] fValue - float value.
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindFloat( pItem->pValue, fValue );
}
LONG
DynArrayFindDouble2(
TARRAY pArray,
DWORD dwRow,
double dblValue
)
/*++
// Routine Description:
// This function returns the index of the double type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row posn
// [ in ] dblValue - the item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindDouble( pItem->pValue, dblValue );
}
LONG
DynArrayFindHandle2(
TARRAY pArray,
DWORD dwRow,
HANDLE hValue
)
/*++
// Routine Description:
// This function returns the index of the HANDLE type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row posn
// [ in ] hValue - the HANDLE type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindHandle( pItem->pValue, hValue );
}
LONG
DynArrayFindSystemTime2(
TARRAY pArray,
DWORD dwRow,
SYSTEMTIME stValue
)
/*++
// Routine Description:
// This function returns the index of the SYSTEMTIME type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row posn
// [ in ] stValue - the SYSTEMTIME type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindSystemTime( pItem->pValue, stValue );
}
LONG
DynArrayFindFileTime2(
TARRAY pArray,
DWORD dwRow,
FILETIME ftValue
)
/*++
// Routine Description:
// This function returns the index of the FILETIME type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row posn
// [ in ] ftValue - the FILETIME type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayFindFileTime( pItem->pValue, ftValue );
}
LONG
DynArrayFindLongEx(
TARRAY pArray,
DWORD dwColumn,
LONG lValue
)
/*++
// Routine Description:
// This function returns the index of the LONG type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] lValue - the LONG type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_LONG, &lValue, FALSE, 0 );
}
LONG
DynArrayFindDWORDEx(
TARRAY pArray,
DWORD dwColumn,
DWORD dwValue
)
/*++
// Routine Description:
// This function returns the index of the DWORD type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] dwValue - the DWORD type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_DWORD, &dwValue, FALSE, 0 );
}
LONG
DynArrayFindFloatEx(
TARRAY pArray,
DWORD dwColumn,
float fValue
)
/*++
// Routine Description:
// This function returns the index of the fValue type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] fValue - the float type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_FLOAT, &fValue, FALSE, 0 );
}
LONG
DynArrayFindDoubleEx(
TARRAY pArray,
DWORD dwColumn,
double dblValue
)
/*++
// Routine Description:
// This function returns the index of the double type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] dblValue - the double type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_DOUBLE, &dblValue, FALSE, 0 );
}
LONG
DynArrayFindHandleEx(
TARRAY pArray,
DWORD dwColumn,
HANDLE hValue
)
/*++
// Routine Description:
// This function returns the index of the HANDLE type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] hValue - the HANDLE type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_HANDLE, &hValue, FALSE, 0 );
}
LONG
DynArrayFindSystemTimeEx(
TARRAY pArray,
DWORD dwColumn,
SYSTEMTIME stValue
)
/*++
// Routine Description:
// This function returns the index of the SYSTEMTIME type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] stValue - the SYSTEMTIME type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_SYSTEMTIME, &stValue, FALSE, 0 );
}
LONG
DynArrayFindFileTimeEx(
TARRAY pArray,
DWORD dwColumn,
FILETIME ftValue
)
/*++
// Routine Description:
// This function returns the index of the FILETIME type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] ftValue - the FILETIME type item to be searched. .
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn, DA_TYPE_FILETIME, &ftValue, FALSE, 0 );
}
LONG
DynArrayFindStringEx(
TARRAY pArray,
DWORD dwColumn,
LPCWSTR szValue,
BOOL bIgnoreCase,
DWORD dwCount
)
/*++
// Routine Description:
// This function returns the index of the string type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwColumn - column posn
// [ in ] szValue - pointer to the string
// [ in ] bIgnorecase - boolean for case sensitive search.
// [ in ] dwCount - string length
//
// Return Value:
// the index of the element .
--*/
{
// return the value
return __DynArrayFindEx( pArray, dwColumn,
DA_TYPE_STRING, (LPVOID) szValue, bIgnoreCase, dwCount );
}
LONG
DynArrayAppendEx(
TARRAY pArray,
TARRAY pArrItem
)
/*++
// Routine Description:
// This function returns the index of the FILETIME type variable from a 2-d array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] pArrItem - Dynamic Array to be appended.
//
// Return Value:
// the pointer to the array.
--*/
{
// validate the array
if ( ( FALSE == IsValidArray( pArray ) ) ||
( FALSE == IsValidArray( pArrItem ) ) )
{
return -1; // array is not valid
}
// now add this sub array to the main array and return the result
return __DynArrayAppend( pArray, DA_TYPE_ARRAY, sizeof( TARRAY ), pArrItem );
}
LONG
DynArrayInsertEx(
TARRAY pArray,
DWORD dwIndex,
TARRAY pArrItem
)
/*++
// Routine Description:
// replaces a element with an dynamic array.
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - Dynamic Array to be appended.
// [ in ] pArrItem - pointer to the TARRAY.
//
// Return Value:
// the pointer to the array..
--*/
{
// validate the array
if ( ( FALSE == IsValidArray( pArray ) ) ||
( FALSE == IsValidArray( pArrItem ) ) )
{
return -1; // array is not valid
}
// now insert this sub array to the main array and check the result
return __DynArrayInsert( pArray, dwIndex, DA_TYPE_ARRAY, sizeof( TARRAY ), pArrItem );
}
BOOL
DynArraySetEx(
TARRAY pArray,
DWORD dwIndex,
TARRAY pArrItem
)
/*++
// Routine Description:
// inserts a dynamic array at the specified posn..
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwIndex - Dynamic Array to be appended.
// [ in ] pArrItem - pointer to the TARRAY.
//
// Return Value:
// the pointer to the array..
--*/
{
// local variables
__PTITEM pItem = NULL;
// validate the array
if ( FALSE == IsValidArray( pArray ) ||
FALSE == IsValidArray( pArrItem ) )
{
return FALSE;
}
// get the item at the required index
pItem = __DynArrayGetItem( pArray, dwIndex, NULL );
if ( NULL == pItem )
{
return FALSE; // item not found / invalid array pointer
}
// check the data type ... it should not be initialized yet or of array type
if ( ( DA_TYPE_ARRAY != pItem->dwType ) && ( _TYPE_NEEDINIT != pItem->dwType ) )
{
return FALSE;
}
// set the value of the current item
pItem->pValue = pArrItem;
pItem->dwType = DA_TYPE_ARRAY;
// return the result
return TRUE;
}
LONG
DynArrayAppendEx2(
TARRAY pArray,
DWORD dwRow,
TARRAY pArrItem
)
/*++
// Routine Description:
// appends a dynamic array at the specified posn..
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row no
// [ in ] pArrItem - pointer to the TARRAY.
//
// Return Value:
// the pointer to the array..
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayAppendEx( pItem->pValue, pArrItem );
}
LONG
DynArrayInsertEx2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColIndex,
TARRAY pArrItem
)
/*++
// Routine Description:
// inserts a dynamic array at the specified posn..
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row value
// [ in ] dwColIndex - column posn.
// [ in ] pArrItem - pointer to the TARRAY.
//
// Return Value:
// the pointer to the array..
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArrayInsertEx( pItem->pValue, dwColIndex, pArrItem );
}
BOOL
DynArraySetEx2(
TARRAY pArray,
DWORD dwRow,
DWORD dwColumn,
TARRAY pArrItem
)
/*++
// Routine Description:
// creates a dynamic array at the specified posn of the 2-d array
//
// Arguments:
// [ in ] pArray - Dynamic Array
// [ in ] dwRow - row position
// [ in ] dwColIndex - column posn.
// [ in ] pArrItem - pointer to the TARRAY.
//
// Return Value:
// the pointer to the array..
--*/
{
// local variables
__PTITEM pItem = NULL;
// get the item at the required row
pItem = __DynArrayGetItem( pArray, dwRow, NULL );
if ( ( NULL == pItem ) ||
( DA_TYPE_ARRAY != pItem->dwType ) )
{
return -1; // no item exists at the specified row or item is not of type array
}
// return the value
return DynArraySetEx( pItem->pValue, dwColumn, pArrItem );
}