PARCBuffer *
tutorialFileIO_CreateDirectoryListing(const char *directoryName)
{
DIR *directory = opendir(directoryName);
assertNotNull(directory, "Couldn't open directory '%s' for reading.", directoryName);
PARCBufferComposer *directoryListing = parcBufferComposer_Create();
struct dirent *entry;
while ((entry = readdir(directory)) != NULL) {
switch (entry->d_type) {
case DT_REG: {
// a regular file
// We need the full file path to check its size.
PARCBufferComposer *fullFilePath = parcBufferComposer_Create();
parcBufferComposer_Format(fullFilePath, "%s/%s", directoryName, entry->d_name);
PARCBuffer *fileNameBuffer = parcBufferComposer_ProduceBuffer(fullFilePath);
char *fullFilePathString = parcBuffer_ToString(fileNameBuffer);
parcBuffer_Release(&fileNameBuffer);
if (tutorialFileIO_IsFileAvailable(fullFilePathString)) {
parcBufferComposer_Format(directoryListing, " %s (%zu bytes)\n",
entry->d_name, tutorialFileIO_GetFileSize(fullFilePathString));
}
parcBufferComposer_Release(&fullFilePath);
parcMemory_Deallocate((void **) &fullFilePathString);
break;
}
case DT_LNK:
case DT_DIR:
default:
// ignore everything but regular files
break;
}
}
closedir(directory);
PARCBuffer *result = parcBufferComposer_ProduceBuffer(directoryListing);
parcBufferComposer_Release(&directoryListing);
return result;
}
PARCBufferComposer *
parcLock_BuildString(const PARCLock *lock, PARCBufferComposer *composer)
{
parcBufferComposer_Format(composer, "lock{.state=%s }", lock->locked ? "true" : "false");
return composer;
}
PARCBuffer *
parcLogFormatText_FormatEntry(const PARCLogEntry *entry)
{
PARCBuffer *payload = parcLogEntry_GetPayload(entry);
char theTime[64];
parcTime_TimevalAsRFC3339(parcLogEntry_GetTimeStamp(entry), theTime);
PARCBufferComposer *composer = parcBufferComposer_Allocate(128);
parcBufferComposer_PutStrings(composer,
theTime, " ",
parcLogLevel_ToString(parcLogEntry_GetLevel(entry)), " ",
parcLogEntry_GetHostName(entry), " ",
parcLogEntry_GetApplicationName(entry), " ",
parcLogEntry_GetProcessName(entry), " ", NULL);
parcBufferComposer_Format(composer, "%" PRId64 " [ ", parcLogEntry_GetMessageId(entry));
parcBufferComposer_PutBuffer(composer, payload);
parcBufferComposer_PutStrings(composer, " ]\n", NULL);
PARCBuffer *result = parcBuffer_Flip(parcBuffer_Acquire(parcBufferComposer_GetBuffer(composer)));
parcBufferComposer_Release(&composer);
return result;
}
PARCBufferComposer *
cpiInterfaceGeneric_BuildString(const CPIInterfaceGeneric *interface, PARCBufferComposer *composer)
{
char *addressString = cpiAddressList_ToString(interface->addresses);
parcBufferComposer_Format(composer, "%5d %4s %s",
interface->ifidx,
cpiInterfaceStateType_ToString(interface->state),
addressString
);
parcMemory_Deallocate((void **) &addressString);
return composer;
}
static PARCBufferComposer *
_buildStringNumber(const PARCJSONValue *value, PARCBufferComposer *string)
{
if (value->value.number.internalDoubleRepresentation) {
parcBufferComposer_Format(string, "%Lf", value->value.number.internalDoubleValue);
} else {
parcBufferComposer_Format(string, "%s%" PRId64,
value->value.number.sign == -1 ? "-" : "",
value->value.number.whole);
if (value->value.number.fraction > 0) {
parcBufferComposer_Format(string, ".%0*" PRId64,
(int) value->value.number.fractionLog10,
value->value.number.fraction);
}
if (value->value.number.exponent != 0) {
parcBufferComposer_Format(string, "e%" PRId64,
value->value.number.exponent);
}
}
return string;
}
PARCBufferComposer *
ccnxPortalAnchor_BuildString(const CCNxPortalAnchor *anchor, PARCBufferComposer *composer)
{
char *name = ccnxName_ToString(anchor->prefix);
char expireTime[64];
if (anchor->expireTime == -1) {
strcpy(expireTime, " never");
} else {
parcTime_TimeAsRFC3339(anchor->expireTime, expireTime);
}
parcBufferComposer_Format(composer, "{ %s %s }", name, expireTime);
parcMemory_Deallocate(&name);
return composer;
}
PARCBufferComposer *
parcHashMap_BuildString(const PARCHashMap *hashMap, PARCBufferComposer *composer)
{
PARCIterator *iterator = parcHashMap_CreateKeyIterator((PARCHashMap *) hashMap);
while (parcIterator_HasNext(iterator)) {
PARCObject *keyObject = parcIterator_Next(iterator);
const PARCObject *valueObject = parcHashMap_Get(hashMap, keyObject);
char *key = parcObject_ToString(keyObject);
char *value = parcObject_ToString(valueObject);
parcBufferComposer_Format(composer, "%s -> %s\n", key, value);
parcMemory_Deallocate(&key);
parcMemory_Deallocate(&value);
}
parcIterator_Release(&iterator);
return composer;
}
static char *
_toString(const PARCLogEntry *entry)
{
PARCBufferComposer *composer = parcBufferComposer_Create();
parcBufferComposer_Format(composer, "%ld.%06d %d ",
(long) entry->timeStamp.tv_sec, (int) entry->timeStamp.tv_usec, entry->level);
size_t position = parcBuffer_Position(entry->payload);
parcBufferComposer_PutBuffer(composer, entry->payload);
parcBuffer_SetPosition(entry->payload, position);
PARCBuffer *buffer = parcBufferComposer_GetBuffer(composer);
parcBuffer_Rewind(buffer);
char *result = parcBuffer_ToString(buffer);
parcBufferComposer_Release(&composer);
return result;
}
static const char *
_moduleNameToLibrary(const char *moduleName)
{
char *result = NULL;
assertNotNull(moduleName, "module name must not be null");
const char *module = _strtoupper(moduleName);
PARCBufferComposer *composer = parcBufferComposer_Create();
if (composer != NULL) {
parcBufferComposer_Format(composer, "%s%s%s",
LIBRARY_MODULE_PREFIX, module, LIBRARY_MODULE_SUFFIX);
PARCBuffer *tempBuffer = parcBufferComposer_ProduceBuffer(composer);
parcBufferComposer_Release(&composer);
result = parcBuffer_ToString(tempBuffer);
parcBuffer_Release(&tempBuffer);
}
parcMemory_Deallocate(&module);
return result;
}
