inline void CompImageLoader::Load(size_t size, ui8 color) { if (!size) return; if (color==0xff) { auto tmpbuf = new ui8[size]; memset((void*)tmpbuf, color, size); Load(size, tmpbuf); delete [] tmpbuf; return; } //Current entry is RLE with same color as new block if (entry && entry[0] == color) { size_t toCopy = std::min<size_t>(size, 255 - entry[1]); size -= toCopy; entry[1] += toCopy; } //Create new entries while (size > 255) { NewEntry(color, 255); size -= 255; } if (size) NewEntry(color, size); }
int hdbm_insert(hdbm db, datum key, datum value) /* Insert a new entry into the table without looking for duplicates. The datums (key and value) are duplicated. Return 1 on sucess, 0 on failure. */ { entry *top = NewEntry(key, value); call_stats.inserts++; if (!top) return 0; if (!hdbm_check(db)) { fprintf(stderr, "hdbm_insert: invalid database handle %d\n", db); return 0; } if (hash_tables[db].file) { /* If using a file write key/pair to file and free memory for value */ int status = write_file_entry(db, top); datum_free(top->value); top->value.dptr = 0; if (!status) return 0; } put_in_bin(db, top); return 1; }
static int hdbm_load(hdbm db, FILE *file) /* Check that the file is indeed a data base and load data in */ { char header[32]; file_entry fe; long rec_ptr; rewind(file); if ((hdbm_fread(header, sizeof(cookie), (size_t) 1, file) != 1) || (strncmp(header, cookie, strlen(cookie)) != 0)) { (void) fprintf(stderr, "hdbm_load: cookie missing ... not a database\n"); return 0; } /* Now simply keep reading until we hit end of file */ rec_ptr = ftell(file); while (!hdbm_fseek(file, rec_ptr, SEEK_SET) && (hdbm_fread((char *) &fe, sizeof(fe), (size_t) 1, file) == 1)) { datum key, value; entry *e; if (fe.active) { if (!datum_fread(file, rec_ptr+sizeof(fe), fe.key_size, &key)) { (void) fprintf(stderr, "hdbm_load: header present but key missing?\n"); return 0; } value.dptr = 0; value.dsize = fe.val_size; if (!(e = NewEntry(key, value))) return 0; datum_free(key); datum_free(value); e->rec_ptr = rec_ptr; e->val_ptr = rec_ptr + ((long) sizeof(fe)) + fe.key_size; put_in_bin(db, e); } rec_ptr = rec_ptr + ((long) sizeof(fe)) + fe.key_size + fe.val_size; } /* Now check that we really are at EOF */ (void) hdbm_fseek(file, 0L, SEEK_END); if (rec_ptr != ftell(file)) { fprintf(stderr, "hdbm_load: inconsistent end to file %ld != %ld\n", rec_ptr, ftell(file)); } return TRUE; }
void RegistryObjectReferenceMap::Put(int key, const SmartPointer<RegistryObject>& value) { if (value.IsNull()) throw ctkInvalidArgumentException("null values not allowed"); Purge(); ReferenceMapType::Iterator i = references.find(key); if (i != references.end()) { delete *i; } references.insert(key, NewEntry(value)); }
TSharedRef<FString, ESPMode::ThreadSafe> FTextLocalizationManager::GetString(const FString& Namespace, const FString& Key, const FString* const SourceString) { FScopeLock ScopeLock( &SynchronizationObject ); // Hack fix for old assets that don't have namespace/key info if(Namespace.IsEmpty() && Key.IsEmpty()) { return MakeShareable( new FString( SourceString ? **SourceString : TEXT("") ) ); } #if ENABLE_LOC_TESTING const bool bShouldLEETIFYAll = bIsInitialized && FInternationalization::Get().GetCurrentCulture()->GetName() == TEXT("LEET"); // Attempt to set bShouldLEETIFYUnlocalizedString appropriately, only once, after the commandline is initialized and parsed static bool bShouldLEETIFYUnlocalizedString = false; { static bool bHasParsedCommandLine = false; if(!bHasParsedCommandLine && FCommandLine::IsInitialized()) { bShouldLEETIFYUnlocalizedString = FParse::Param(FCommandLine::Get(), TEXT("LEETIFYUnlocalized")); bHasParsedCommandLine = true; } } #endif // Find namespace's key table. FTextLookupTable::FKeyTable* LiveKeyTable = LiveTable.NamespaceTable.Find( Namespace ); // Find key table's entry. FStringEntry* LiveEntry = LiveKeyTable ? LiveKeyTable->Find( Key ) : NULL; // Entry is present. if( LiveEntry ) { // If we're in some sort of development setting, source may have changed but localization resources have not, in which case the source should be used. const uint32 SourceStringHash = SourceString ? FCrc::StrCrc32(**SourceString) : 0; // If the source string (hash) is different, the local source has changed and should override - can't be localized. if( SourceStringHash != 0 && SourceStringHash != LiveEntry->SourceStringHash ) { LiveEntry->SourceStringHash = SourceStringHash; LiveEntry->String.Get() = SourceString ? **SourceString : TEXT(""); #if ENABLE_LOC_TESTING if( (bShouldLEETIFYAll || bShouldLEETIFYUnlocalizedString) && SourceString ) { FInternationalization::Leetify(*LiveEntry->String); if(*LiveEntry->String == *SourceString) { UE_LOG(LogTextLocalizationManager, Warning, TEXT("Leetify failed to alter a string (%s)."), **SourceString ); } } #endif UE_LOG(LogTextLocalizationManager, Verbose, TEXT("An attempt was made to get a localized string (Namespace:%s, Key:%s), but the source string hash does not match - the source string (%s) will be used."), *Namespace, *Key, **LiveEntry->String); #if ENABLE_LOC_TESTING LiveEntry->bIsLocalized = bShouldLEETIFYAll; #else LiveEntry->bIsLocalized = false; #endif } return LiveEntry->String; } // Entry is absent. else { // Don't log warnings about unlocalized strings if the system hasn't been initialized - we simply don't have localization data yet. if( bIsInitialized ) { UE_LOG(LogTextLocalizationManager, Verbose, TEXT("An attempt was made to get a localized string (Namespace:%s, Key:%s, Source:%s), but it did not exist."), *Namespace, *Key, SourceString ? **SourceString : TEXT("")); } const TSharedRef<FString, ESPMode::ThreadSafe> UnlocalizedString = MakeShareable( new FString( SourceString ? **SourceString : TEXT("") ) ); // If live-culture-swap is enabled or the system is uninitialized - make entries so that they can be updated when system is initialized or a culture swap occurs. CA_SUPPRESS(6236) CA_SUPPRESS(6316) if( !(bIsInitialized) || ENABLE_LOC_TESTING ) { #if ENABLE_LOC_TESTING if( (bShouldLEETIFYAll || bShouldLEETIFYUnlocalizedString) && SourceString ) { FInternationalization::Leetify(*UnlocalizedString); if(*UnlocalizedString == *SourceString) { UE_LOG(LogTextLocalizationManager, Warning, TEXT("Leetify failed to alter a string (%s)."), **SourceString ); } } #endif if ( UnlocalizedString->IsEmpty() ) { if ( !bIsInitialized ) { *(UnlocalizedString) = AccessedStringBeforeLocLoadedErrorMsg; } } FStringEntry NewEntry( #if ENABLE_LOC_TESTING bShouldLEETIFYAll /*bIsLocalized*/ #else false /*bIsLocalized*/ #endif , TEXT("") , SourceString ? FCrc::StrCrc32(**SourceString) : 0 /*SourceStringHash*/ , UnlocalizedString /*String*/ ); if( !LiveKeyTable ) { LiveKeyTable = &(LiveTable.NamespaceTable.Add( Namespace, FTextLookupTable::FKeyTable() )); } LiveKeyTable->Add( Key, NewEntry ); ReverseLiveTable.Add(NewEntry.String, FNamespaceKeyEntry( MakeShareable( new FString( Namespace ) ), MakeShareable( new FString( Key ) ))); } return UnlocalizedString; } }
for (TObjectIterator<UClass> It; It; ++It) { UClass* Class = *It; // If this is a subclass of Actor Component, not abstract, and tagged as spawnable from Kismet if (Class->IsChildOf(UActorComponent::StaticClass())) { InMemoryClasses.Push(Class->GetFName()); if (!Class->HasAnyClassFlags(CLASS_Abstract) && Class->HasMetaData(FBlueprintMetadata::MD_BlueprintSpawnableComponent) && !FKismetEditorUtilities::IsClassABlueprintSkeleton(Class)) //@TODO: Fold this logic together with the one in UEdGraphSchema_K2::GetAddComponentClasses { TArray<FString> ClassGroupNames; Class->GetClassGroupNames(ClassGroupNames); if (ClassGroupNames.Contains(CommonClassGroup)) { FString ClassGroup = CommonClassGroup; FComponentClassComboEntryPtr NewEntry(new FComponentClassComboEntry(ClassGroup, Class, ClassGroupNames.Num() <= 1, EComponentCreateAction::SpawnExistingClass)); SortedClassList.Add(NewEntry); } if (ClassGroupNames.Num() && !ClassGroupNames[0].Equals(CommonClassGroup)) { const bool bIncludeInFilter = true; FString ClassGroup = ClassGroupNames[0]; FComponentClassComboEntryPtr NewEntry(new FComponentClassComboEntry(ClassGroup, Class, bIncludeInFilter, EComponentCreateAction::SpawnExistingClass)); SortedClassList.Add(NewEntry); } } bool const bOutOfDateClass = Class->HasAnyClassFlags(CLASS_NewerVersionExists); if (!bOutOfDateClass && !FKismetEditorUtilities::IsClassABlueprintSkeleton(Class)) {
inline void CompImageLoader::Load(size_t size, const ui8 * data) { while (size) { //Try to compress data while(true) { ui8 color = data[0]; if (color != 0xff) { size_t runLength = 1; while (runLength < size && color == data[runLength]) runLength++; if (runLength > 1 && runLength < 255)//Row of one color found - use RLE { Load(runLength, color); data += runLength; size -= runLength; if (!size) return; } else break; } else break; } //Select length for new raw entry size_t runLength = 1; ui8 color = data[0]; ui8 type = typeOf(color); ui8 color2; ui8 type2; if (size > 1) { do { color2 = data[runLength]; type2 = typeOf(color2); runLength++; } //While we have data of this type and different colors while ((runLength < size) && (type == type2) && ( (color2 != 0xff) || (color2 != color))); } size -= runLength; //add data to last entry if (entry && entry[0] == 0xff && type == typeOf(entry[2])) { size_t toCopy = std::min<size_t>(runLength, 255 - entry[1]); runLength -= toCopy; entry[1] += toCopy; memcpy(position, data, toCopy); data+=toCopy; position+=toCopy; } //Create new entries while (runLength > 255) { NewEntry(data, 255); runLength -= 255; } if (runLength) NewEntry(data, runLength); } }
indextype FindEntry(struct matrix *m, const byte *key, const int create) { indextype hashidx, *storeidx, idx; hashidx = CalculateHashIndex(m, key); storeidx = &(m->hash[hashidx]); if (*storeidx < 0) { /* There is no node here */ if (create <= 0) return (-1); /* Delete or read, nothing to do */ *storeidx = NewEntry(m); m->next[*storeidx] = -1; m->prev[*storeidx] = hashidx; idx = *storeidx; } else { const int cr = memcmp(&(m->keys[*storeidx * m->key_size]), key, m->key_size); if (cr > 0) { /* The node is to be created as the first of the list */ if (create <= 0) return (-1); idx = *storeidx; *storeidx = NewEntry(m); m->next[*storeidx] = idx; m->prev[*storeidx] = hashidx; m->prev[idx] = -*storeidx - 1; idx = *storeidx; } else if (cr == 0) { /* The node is the first node */ if (create >= 0) return (*storeidx); /* Ok, the node should be deleted then ... */ RemoveEntryIdx(m, *storeidx); return (-1); } else { /* Node is somewhere in the list ? */ idx = *storeidx; while (m->next[idx] >= 0 && (memcmp(&(m->keys[m->next[idx] * m->key_size]), key, m->key_size) <= 0)) { idx = m->next[idx]; } if (!memcmp(&(m->keys[idx * m->key_size]), key, m->key_size)) { /* Ok, found and return */ if (create >= 0) return (idx); RemoveEntryIdx(m, idx); return (-1); } /* Was not in the list */ if (create <= 0) return (-1); { const indextype idx3 = idx; idx = NewEntry(m); m->next[idx] = m->next[idx3]; m->next[idx3] = idx; m->prev[idx] = -idx3 - 1; if (m->next[idx] != -1) m->prev[m->next[idx]] = -idx - 1; } } } // assert(idx>=0); memcpy(&(m->keys[idx * m->key_size]), key, m->key_size); memcpy(&(m->data[idx * m->size_of_entry]), m->default_value, m->size_of_entry); return (idx); }