void FCollectionManager::LoadCollections()
{
const double LoadStartTime = FPlatformTime::Seconds();
int32 NumCollectionsLoaded = 0;
for (int32 CacheIdx = 0; CacheIdx < ECollectionShareType::CST_All; ++CacheIdx)
{
const FString& CollectionFolder = CollectionFolders[CacheIdx];
const FString WildCard = FString::Printf(TEXT("%s/*.%s"), *CollectionFolder, *CollectionExtension);
TArray<FString> Filenames;
IFileManager::Get().FindFiles(Filenames, *WildCard, true, false);
for (int32 FileIdx = 0; FileIdx < Filenames.Num(); ++FileIdx)
{
const FString Filename = CollectionFolder / Filenames[FileIdx];
FCollection Collection;
const bool bUseSCC = ShouldUseSCC(ECollectionShareType::Type(CacheIdx));
if ( Collection.LoadFromFile(Filename, bUseSCC) )
{
AddCollection(Collection, ECollectionShareType::Type(CacheIdx));
}
else
{
UE_LOG(LogCollectionManager, Warning, TEXT("Failed to load collection file %s"), *Filename);
}
}
NumCollectionsLoaded += CachedCollections[CacheIdx].Num();
}
UE_LOG( LogCollectionManager, Log, TEXT( "Loaded %d collections in %0.6f seconds" ), NumCollectionsLoaded, FPlatformTime::Seconds() - LoadStartTime );
}
void CMsregPacketCatalogOrderLineItem::ReadDataFromFile(CFile& cfFile, DWORD& dwChecksum)
{
CString csCollection;
TRY
{
// Read the category name.
m_csCategory = CMsregPacket::ReadString(cfFile, dwChecksum);
// Read the quantity.
m_dwQuantity = CMsregPacket::ReadDword(cfFile, dwChecksum);
// Write the cost.
m_dwCost = CMsregPacket::ReadDword(cfFile, dwChecksum);
// Read the collection count.
DWORD dwCollections = CMsregPacket::ReadDword(cfFile, dwChecksum);
// Read Collections.
DeleteAllCollections();
for (DWORD i = 0; i < dwCollections; i++)
{
csCollection = CMsregPacket::ReadString(cfFile, dwChecksum);
AddCollection(csCollection);
}
}
CATCH_ALL(e)
{
csCollection.Empty();
THROW_LAST();
}
END_CATCH_ALL
}
static void ScanPath (TRI_vocbase_t* vocbase, char const* path) {
TRI_vector_string_t files;
TRI_col_type_e type;
size_t n;
size_t i;
files = TRI_FilesDirectory(path);
n = files._length;
for (i = 0; i < n; ++i) {
char* name;
char* file;
name = files._buffer[i];
if (name[0] == '\0' || name[0] == '_' || name[0] == '.') {
continue;
}
file = TRI_Concatenate2File(path, name);
if (!file) {
continue;
}
if (TRI_IsDirectory(file)) {
TRI_col_info_t info;
bool ok;
ok = TRI_LoadParameterInfo(file, &info);
if (! ok) {
LOG_DEBUG("ignoring directory '%s' without valid parameter file '%s'", file, TRI_COL_PARAMETER_FILE);
}
else {
type = info._type;
if (type == TRI_COL_TYPE_SIMPLE_DOCUMENT) {
AddCollection(vocbase, type, info._name, info._cid, file);
LOG_DEBUG("added simple document collection from '%s'", file);
}
else {
LOG_DEBUG("skipping collection of unknown type %d", (int) type);
}
}
}
else {
LOG_DEBUG("ignoring non-directory '%s'", file);
}
TRI_FreeString(file);
}
TRI_DestroyVectorString(&files);
}
void IPCCollectionEvent(int argc, char** argv, PLSOBJECT Object)
{
char* Name = argv[0];
LSTypeDefinition* Type = pLSInterface->FindLSType(argv[1]);
char* SubType = argv[2];
char* Method = argv[3];
LSOBJECT collectionobject;
if((collectionobject.Ptr = FindCollection(Name)) == 0)
{
collectionobject.Ptr = new LSObjectCollection(Type, SubType);
AddCollection(Name, (LSObjectCollection*)collectionobject.Ptr);
}
pCollectionType->GetMethodEx(collectionobject.GetObjectData(), Method, argc - 4, &argv[4]);
}
bool FCollectionManager::CreateCollection(FName CollectionName, ECollectionShareType::Type ShareType)
{
if ( !ensure(ShareType < ECollectionShareType::CST_All) )
{
// Bad share type
LastError = LOCTEXT("Error_Internal", "There was an internal error.");
return false;
}
// Try to add the collection
bool bUseSCC = ShouldUseSCC(ShareType);
FString SourceFolder = CollectionFolders[ShareType];
FCollection NewCollection(CollectionName, SourceFolder, CollectionExtension, bUseSCC);
FCollection* Collection = AddCollection(NewCollection, ShareType);
if ( !Collection )
{
// Failed to add the collection, it already exists
LastError = LOCTEXT("Error_AlreadyExists", "The collection already exists.");
return false;
}
if ( Collection->Save(LastError) )
{
// Collection saved!
CollectionCreatedEvent.Broadcast( FCollectionNameType( CollectionName, ShareType ) );
return true;
}
else
{
// Collection failed to save, remove it from the cache
RemoveCollection(Collection, ShareType);
return false;
}
}
bool IPCCollectionType::GetMethod(LSOBJECTDATA &ObjectData, PLSTYPEMETHOD pMethod, int argc, char *argv[])
{
/*******************************************
* Parameters
*
* [in] LSOBJECTDATA ObjectData: ObjectData is a 32-bit value that can be accessed in any number of different ways
* by way of union. Most commonly, ObjectData.Ptr, ObjectData.DWord, or ObjectData.CharPtr are useful. This
* value is the representation of some object of this object type. "ipcfoo" works on IPCFoo*
* so ObjectData is a IPCFoo*
*
* [in] PLSTYPEMETHOD pMethod: pMethod is a pointer to the information on the method to be retrieved, including its
* Name and ID. We use the ID in a switch statement in order to quickly process the method, since the Name
* has already been resolved by the LavishScript engine.
*
* [in] int argc, char *argv[]: argc and argv are *nearly* standard C console program parameters. The difference here
* is that the name of the method is NOT given as the first argument (in contrast to LavishScript commands).
* Therefore, argc is 0 unless arguments are specifically given to the method retrieval.
*/
/*******************************************
* Return Value
*
* The return value for this function is very simple. If the method execution fails for any reason, OR the object
* is destroyed during execution, return false. Otherwise, return true (indicating the object still exists AND
* the method execution succeeded).
*
*/
/* Validate the pointer */
if (!pCollection)
return false;
/* Perform the given member retrieval */
switch(pMethod->ID)
{
case Erase:
if(argc)
{
pCollection->Collection->RemoveItem(argv[0]);
CollectionRelay(pCollection->IPCName, pCollection->Type->GetName(), pCollection->SubType, "Erase", argc, argv);
return true;
}
return false;
case Clear:
pCollection->Collection->Clear();
CollectionRelay(pCollection->IPCName, pCollection->Type->GetName(), pCollection->SubType, "Clear", argc, argv);
return true;
case Set:
if (argc>1)
{
pCollection->Collection->SetItem(argv[0], argc-1, &argv[1]);
CollectionRelay(pCollection->IPCName, pCollection->Type->GetName(), pCollection->SubType, "Set", argc, argv);
return true;
}
case SetIPCName:
if(argc==1)
{
LSObjectCollection *newCollection;
strncpy(pCollection->IPCName, argv[0], sizeof(pCollection->IPCName));
if((newCollection=FindCollection(pCollection->IPCName))==0)
{
newCollection = new LSObjectCollection(pCollection->Type, pCollection->SubType);
AddCollection(pCollection->IPCName, newCollection);
}
pCollection->Collection = newCollection;
return true;
}
return false;
case GetIterator:
LSOBJECT iteratorobject;
if(argc)
{
//printf("%s %s %d", argv[0], pCollection->IPCName, pCollection->Collection->GetContainerUsed());
if(pLSInterface->DataParse(argv[0], iteratorobject))
{
return InitializeIterator(pCollection->Collection, 0, iteratorobject);
}
}
return false;
}
return false;
}