unsigned long Dictionary_GetUnsignedLong_WithDefault( Dictionary* dictionary, Dictionary_Entry_Key key, const unsigned long defaultVal ) { return Dictionary_Entry_Value_AsUnsignedLong( Dictionary_GetDefault( dictionary, key, Dictionary_Entry_Value_FromUnsignedLong( defaultVal ) ) ); }
Dictionary_Entry_Value* Dictionary_Entry_Value_FromStringTo( char* string, char type ) { Dictionary_Entry_Value* retValue = Memory_Alloc( Dictionary_Entry_Value, "Return Value" ); /* need to create the value temporarily so it can be converted if necessary */ retValue->type = Dictionary_Entry_Value_Type_String; if ( string ) { retValue->as.typeString = ExpandEnvironmentVariables( string ); } else { retValue->as.typeString = string; } switch (type) { case Dictionary_Entry_Value_Type_String: Dictionary_Entry_Value_InitFromString( retValue, retValue->as.typeString ); break; case Dictionary_Entry_Value_Type_Double: Dictionary_Entry_Value_InitFromDouble( retValue, Dictionary_Entry_Value_AsDouble( retValue ) ); break; case Dictionary_Entry_Value_Type_UnsignedInt: Dictionary_Entry_Value_InitFromUnsignedInt( retValue, Dictionary_Entry_Value_AsUnsignedInt( retValue ) ); break; case Dictionary_Entry_Value_Type_Int: Dictionary_Entry_Value_InitFromInt( retValue, Dictionary_Entry_Value_AsInt( retValue ) ); break; case Dictionary_Entry_Value_Type_UnsignedLong: Dictionary_Entry_Value_InitFromUnsignedLong( retValue, Dictionary_Entry_Value_AsUnsignedLong( retValue ) ); break; case Dictionary_Entry_Value_Type_Bool: Dictionary_Entry_Value_InitFromBool( retValue, Dictionary_Entry_Value_AsBool( retValue ) ); break; case Dictionary_Entry_Value_Type_Struct: Dictionary_Entry_Value_InitNewStruct( retValue ); break; case Dictionary_Entry_Value_Type_List: Dictionary_Entry_Value_InitNewList( retValue ); break; default: { Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" ); Journal_Firewall( False, errorStream, "In func %s: type '%d' is invalid.\n", __func__, type ); } } return retValue; }
void Dictionary_Entry_Value_SetFromStringKeepCurrentType( Dictionary_Entry_Value* self, char* string ) { Dictionary_Entry_Value_Type currType = self->type; Dictionary_Entry_Value_DeleteContents( self ); self->type = Dictionary_Entry_Value_Type_String; self->as.typeString = string; switch (currType) { case Dictionary_Entry_Value_Type_String: Dictionary_Entry_Value_SetValueString( self, string ); break; case Dictionary_Entry_Value_Type_Double: Dictionary_Entry_Value_SetValueDouble( self, Dictionary_Entry_Value_AsDouble( self ) ); break; case Dictionary_Entry_Value_Type_UnsignedInt: Dictionary_Entry_Value_SetValueUnsignedInt( self, Dictionary_Entry_Value_AsUnsignedInt( self ) ); break; case Dictionary_Entry_Value_Type_Int: Dictionary_Entry_Value_SetValueInt( self, Dictionary_Entry_Value_AsInt( self ) ); break; case Dictionary_Entry_Value_Type_UnsignedLong: Dictionary_Entry_Value_SetValueUnsignedLong( self, Dictionary_Entry_Value_AsUnsignedLong( self ) ); break; case Dictionary_Entry_Value_Type_Bool: Dictionary_Entry_Value_SetValueBool( self, Dictionary_Entry_Value_AsBool( self ) ); break; case Dictionary_Entry_Value_Type_Struct: Dictionary_Entry_Value_SetValueNewStruct( self ); break; case Dictionary_Entry_Value_Type_List: Dictionary_Entry_Value_SetValueNewList( self ); break; default: { Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" ); Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type ); } } }
unsigned long Dictionary_Entry_Value_AsUnsignedLong( Dictionary_Entry_Value* self ) { if( !self ) { return 0.0; } switch( self->type ) { case Dictionary_Entry_Value_Type_Struct: /* Do nothing (later will print a warning) */ return 0; case Dictionary_Entry_Value_Type_List: /* returns the first element as an unsigned long */ if (self->as.typeList->first) { return Dictionary_Entry_Value_AsUnsignedLong( self->as.typeList->first ); } else { return 0; } case Dictionary_Entry_Value_Type_String: return strtod( self->as.typeString, 0 ); case Dictionary_Entry_Value_Type_Double: return self->as.typeDouble; case Dictionary_Entry_Value_Type_UnsignedInt: return (double)self->as.typeUnsignedInt; case Dictionary_Entry_Value_Type_Int: return self->as.typeInt; case Dictionary_Entry_Value_Type_UnsignedLong: return self->as.typeUnsignedLong; case Dictionary_Entry_Value_Type_Bool: return (double)self->as.typeBool; default: { Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" ); Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type ); } } return 0.0; }
Bool Dictionary_Entry_Value_CompareFull( Dictionary_Entry_Value* self, Dictionary_Entry_Value* dev, Bool strictTypeCheck ) { Bool retValue = True; Stream* errorStream = Journal_Register( Error_Type, "Dictionary_Entry_Value" ); if ( strictTypeCheck ) { if ( self->type != dev->type ) { return False; } } switch( self->type ) { case Dictionary_Entry_Value_Type_String: { /* Comparing as strings is tricky. When both are strings it's fine. If the dev to compare to is stored * natively as a number, we should convert the first to a number also for comparison. Otherwise, you * can get false Negatives when the entries are numerically the same, but use different notation * (e.g. scientific vs decimal) */ switch( dev->type ) { case Dictionary_Entry_Value_Type_String: if ( 0 != strcmp( self->as.typeString, dev->as.typeString ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Double: if ( dev->as.typeDouble != Dictionary_Entry_Value_AsDouble( self ) ) retValue = False; break; case Dictionary_Entry_Value_Type_UnsignedInt: if ( dev->as.typeUnsignedInt != Dictionary_Entry_Value_AsUnsignedInt( self ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Int: if ( dev->as.typeInt != Dictionary_Entry_Value_AsInt( self ) ) retValue = False; break; case Dictionary_Entry_Value_Type_UnsignedLong: if ( dev->as.typeUnsignedLong != Dictionary_Entry_Value_AsUnsignedLong( self ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Bool: if ( dev->as.typeBool != Dictionary_Entry_Value_AsBool( self ) ) case Dictionary_Entry_Value_Type_Struct: case Dictionary_Entry_Value_Type_List: retValue = False; break; default: Journal_Firewall( False, errorStream, "In func %s: dev->type '%d' is invalid.\n", __func__, dev->type ); } break; } case Dictionary_Entry_Value_Type_Double: if ( self->as.typeDouble != Dictionary_Entry_Value_AsDouble( dev ) ) retValue = False; break; case Dictionary_Entry_Value_Type_UnsignedInt: if ( self->as.typeUnsignedInt != Dictionary_Entry_Value_AsUnsignedInt( dev ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Int: if ( self->as.typeInt != Dictionary_Entry_Value_AsInt( dev ) ) retValue = False; break; case Dictionary_Entry_Value_Type_UnsignedLong: if ( self->as.typeUnsignedLong != Dictionary_Entry_Value_AsUnsignedLong( dev ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Bool: if ( self->as.typeBool != Dictionary_Entry_Value_AsBool( dev ) ) retValue = False; break; case Dictionary_Entry_Value_Type_Struct: if ( dev->type != Dictionary_Entry_Value_Type_Struct ) { retValue = False; break; } retValue = Dictionary_CompareAllEntriesFull( self->as.typeStruct, dev->as.typeStruct, strictTypeCheck ); break; case Dictionary_Entry_Value_Type_List: { Dictionary_Entry_Value* cur1 = NULL; Dictionary_Entry_Value* cur2 = NULL; if ( dev->type != Dictionary_Entry_Value_Type_List ) { retValue = False; break; } if ( self->as.typeList->count != dev->as.typeList->count ) { retValue = False; break; } cur1 = self->as.typeList->first; cur2 = dev->as.typeList->first; while ( cur1 ) { retValue = Dictionary_Entry_Value_CompareFull( cur1, cur2, strictTypeCheck ); if ( retValue == False ) break; cur1 = cur1->next; cur2 = cur2->next; } break; } default: Journal_Firewall( False, errorStream, "In func %s: self->type '%d' is invalid.\n", __func__, self->type ); }; return retValue; }