nrt_Off CustomIO::adapterTell(NRT_DATA* data,
nrt_Error* error)
{
try
{
return reinterpret_cast<CustomIO*>(data)->tellImpl();
}
catch (const except::Exception& ex)
{
nrt_Error_init(error, ex.getMessage().c_str(), NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return -1;
}
catch (const std::exception& ex)
{
nrt_Error_init(error, ex.what(), NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return -1;
}
catch (...)
{
nrt_Error_init(error, "Unknown error", NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return -1;
}
}
NRT_BOOL CustomIO::adapterRead(NRT_DATA* data,
char* buf,
size_t size,
nrt_Error* error)
{
try
{
reinterpret_cast<CustomIO*>(data)->readImpl(buf, size);
return NRT_SUCCESS;
}
catch (const except::Exception& ex)
{
nrt_Error_init(error, ex.getMessage().c_str(), NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
catch (const std::exception& ex)
{
nrt_Error_init(error, ex.what(), NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
catch (...)
{
nrt_Error_init(error, "Unknown error", NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
}
int CustomIO::adapterGetMode(NRT_DATA* data,
nrt_Error* error)
{
try
{
return reinterpret_cast<CustomIO*>(data)->getMode();
}
catch (const except::Exception& ex)
{
nrt_Error_init(error, ex.getMessage().c_str(), NRT_CTXT,
NRT_ERR_UNK);
return -1;
}
catch (const std::exception& ex)
{
nrt_Error_init(error, ex.what(), NRT_CTXT,
NRT_ERR_UNK);
return -1;
}
catch (...)
{
nrt_Error_init(error, "Unknown error", NRT_CTXT,
NRT_ERR_UNK);
return -1;
}
}
NRTAPI(NRT_DATA *) nrt_List_get(nrt_List * list, int index, nrt_Error * error)
{
int i = 0;
if (list)
{
nrt_ListIterator iter = nrt_List_begin(list);
nrt_ListIterator end = nrt_List_end(list);
for (i = 0; i < index && nrt_ListIterator_notEqualTo(&iter, &end); ++i)
nrt_ListIterator_increment(&iter);
if (i == index && nrt_ListIterator_notEqualTo(&iter, &end))
{
return nrt_ListIterator_get(&iter);
}
else
{
nrt_Error_init(error, "Object not found at index", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
return NULL;
}
}
else
{
nrt_Error_init(error, "Invalid list -> NULL", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
return NULL;
}
}
NRT_BOOL CustomIO::adapterCanSeek(NRT_DATA* data,
nrt_Error* error)
{
try
{
reinterpret_cast<CustomIO*>(data)->canSeekImpl();
return NRT_SUCCESS;
}
catch (const except::Exception& ex)
{
nrt_Error_init(error, ex.getMessage().c_str(), NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return NRT_FAILURE;
}
catch (const std::exception& ex)
{
nrt_Error_init(error, ex.what(), NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return NRT_FAILURE;
}
catch (...)
{
nrt_Error_init(error, "Unknown error", NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
return NRT_FAILURE;
}
}
NRTAPI(NRT_BOOL) nrt_IOHandle_read(nrt_IOHandle handle, char *buf, size_t size,
nrt_Error * error)
{
ssize_t bytesRead = 0; /* Number of bytes read during last read
* operation */
size_t totalBytesRead = 0; /* Total bytes read thus far */
int i; /* iterator */
/* make sure the user actually wants data */
if (size <= 0)
return NRT_SUCCESS;
/* Interrogate the IO handle */
for (i = 1; i <= NRT_MAX_READ_ATTEMPTS; i++)
{
/* Make the next read */
bytesRead = read(handle, buf + totalBytesRead, size - totalBytesRead);
switch (bytesRead)
{
case -1: /* Some type of error occured */
switch (errno)
{
case EINTR:
case EAGAIN: /* A non-fatal error occured, keep trying */
break;
default: /* We failed */
goto CATCH_ERROR;
}
break;
case 0: /* EOF (unexpected) */
nrt_Error_init(error, "Unexpected end of file", NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
default: /* We made progress */
totalBytesRead += (size_t) bytesRead;
} /* End of switch */
/* Check for success */
if (totalBytesRead == size)
{
return NRT_SUCCESS;
}
} /* End of for */
/* We fell out of the for loop (not good) */
/* goto CATCH_ERROR; */
/* An error occured */
CATCH_ERROR:
nrt_Error_init(error, strerror(errno), NRT_CTXT, NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
J2KAPI(j2k_Container*) j2k_Container_construct(nrt_Uint32 gridWidth,
nrt_Uint32 gridHeight,
nrt_Uint32 numComponents,
j2k_Component** components,
nrt_Uint32 tileWidth,
nrt_Uint32 tileHeight,
int imageType,
nrt_Error *error)
{
j2k_Container *container = NULL;
ContainerImpl *impl = NULL;
container = (j2k_Container*) J2K_MALLOC(sizeof(j2k_Container));
if (!container)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(container, 0, sizeof(j2k_Container));
/* create the Container interface */
impl = (ContainerImpl *) J2K_MALLOC(sizeof(ContainerImpl));
if (!impl)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(impl, 0, sizeof(ContainerImpl));
container->data = impl;
container->iface = &ContainerInterface;
impl->gridWidth = gridWidth;
impl->gridHeight = gridHeight;
impl->nComponents = numComponents;
impl->components = components;
impl->tileWidth = tileWidth;
impl->tileHeight = tileHeight;
impl->xTiles = gridWidth / tileWidth + (gridWidth % tileWidth == 0 ? 0 : 1);
impl->yTiles = gridHeight / tileHeight + (gridHeight % tileHeight == 0 ? 0 : 1);
impl->imageType = imageType;
return container;
CATCH_ERROR:
{
if (container)
{
j2k_Container_destruct(&container);
}
return NULL;
}
}
J2KAPI(j2k_Component*) j2k_Component_construct(nrt_Uint32 width,
nrt_Uint32 height,
nrt_Uint32 precision,
NRT_BOOL isSigned,
nrt_Uint32 offsetX,
nrt_Uint32 offsetY,
nrt_Uint32 separationX,
nrt_Uint32 separationY,
nrt_Error *error)
{
j2k_Component *component = NULL;
ComponentImpl *impl = NULL;
component = (j2k_Component*) J2K_MALLOC(sizeof(j2k_Component));
if (!component)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(component, 0, sizeof(j2k_Component));
/* create the Component interface */
impl = (ComponentImpl *) J2K_MALLOC(sizeof(ComponentImpl));
if (!impl)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(impl, 0, sizeof(ComponentImpl));
component->data = impl;
component->iface = &ComponentInterface;
impl->width = width;
impl->height = height;
impl->precision = precision;
impl->isSigned = isSigned;
impl->x0 = offsetX;
impl->y0 = offsetY;
impl->xSeparation = separationX;
impl->ySeparation = separationY;
return component;
CATCH_ERROR:
{
if (component)
{
j2k_Component_destruct(&component);
}
return NULL;
}
}
OpenJPEG_setup(OpenJPEGReaderImpl *impl, opj_stream_t **stream,
opj_codec_t **codec, nrt_Error *error)
{
if (!NRT_IO_SUCCESS(nrt_IOInterface_seek(impl->io,
impl->ioOffset,
NRT_SEEK_SET,
error)))
{
goto CATCH_ERROR;
}
if (!(*stream = OpenJPEG_createIO(impl->io, &impl->userData, 0, 1, error)))
{
goto CATCH_ERROR;
}
if (!(*codec = opj_create_decompress(OPJ_CODEC_J2K)))
{
nrt_Error_init(error, "Error creating OpenJPEG codec", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
goto CATCH_ERROR;
}
memset(error->message, 0, NRT_MAX_EMESSAGE);
if(!opj_set_error_handler(*codec,
OpenJPEG_errorHandler,
error))
{
nrt_Error_init(error, "Unable to set OpenJPEG error handler", NRT_CTXT,
NRT_ERR_UNK);
goto CATCH_ERROR;
}
opj_set_default_decoder_parameters(&impl->parameters);
if (!opj_setup_decoder(*codec, &impl->parameters))
{
/*nrt_Error_init(error, "Error setting up openjpeg decoder", NRT_CTXT,
NRT_ERR_UNK);*/
goto CATCH_ERROR;
}
return NRT_SUCCESS;
CATCH_ERROR:
{
OpenJPEG_cleanup(stream, codec, NULL);
return NRT_FAILURE;
}
}
J2KAPI(j2k_Reader*) j2k_Reader_openIO(nrt_IOInterface *io, nrt_Error *error)
{
OpenJPEGReaderImpl *impl = NULL;
j2k_Reader *reader = NULL;
/* create the Reader interface */
impl = (OpenJPEGReaderImpl *) J2K_MALLOC(sizeof(OpenJPEGReaderImpl));
if (!impl)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(impl, 0, sizeof(OpenJPEGReaderImpl));
reader = (j2k_Reader *) J2K_MALLOC(sizeof(j2k_Reader));
if (!reader)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(reader, 0, sizeof(j2k_Reader));
reader->data = impl;
reader->iface = &ReaderInterface;
/* initialize the interfaces */
impl->io = io;
impl->ioOffset = nrt_IOInterface_tell(io, error);
if (!OpenJPEG_readHeader(impl, error))
{
goto CATCH_ERROR;
}
return reader;
CATCH_ERROR:
{
if (reader)
{
j2k_Reader_destruct(&reader);
}
else if (impl)
{
OpenJPEGReader_destruct((J2K_USER_DATA*) impl);
}
return NULL;
}
}
OpenJPEG_createIO(nrt_IOInterface* io,
IOControl* ioControl,
nrt_Off length,
int isInput,
nrt_Error *error)
{
opj_stream_t *stream = NULL;
stream = opj_stream_create(OPENJPEG_STREAM_SIZE, isInput);
if (!stream)
{
nrt_Error_init(error, "Error creating openjpeg stream", NRT_CTXT,
NRT_ERR_MEMORY);
}
else
{
ioControl->io = io;
ioControl->offset = nrt_IOInterface_tell(io, error);
if (length > 0)
ioControl->length = length;
else
ioControl->length = nrt_IOInterface_getSize(io, error)
- ioControl->offset;
opj_stream_set_user_data(stream, ioControl);
opj_stream_set_read_function(stream, implStreamRead);
opj_stream_set_seek_function(stream, implStreamSeek);
opj_stream_set_skip_function(stream, implStreamSkip);
opj_stream_set_write_function(stream, implStreamWrite);
}
return stream;
}
NRTAPI(nrt_IOHandle) nrt_IOHandle_create(const char *fname,
nrt_AccessFlags access,
nrt_CreationFlags creation,
nrt_Error * error)
{
HANDLE handle;
if (access & NRT_ACCESS_WRITEONLY)
{
WIN32_FIND_DATA findData;
handle = FindFirstFile(fname, &findData);
if (handle != INVALID_HANDLE_VALUE)
{
creation |= TRUNCATE_EXISTING;
FindClose(handle);
}
}
handle =
CreateFile(fname, access, FILE_SHARE_READ, NULL, creation,
FILE_ATTRIBUTE_NORMAL, NULL);
if (handle == INVALID_HANDLE_VALUE)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_OPENING_FILE);
}
return handle;
}
NRTAPI(nrt_ListNode *) nrt_ListNode_construct(nrt_ListNode * prev,
nrt_ListNode * next,
NRT_DATA * data,
nrt_Error * error)
{
nrt_ListNode *node = (nrt_ListNode *) NRT_MALLOC(sizeof(nrt_ListNode));
if (node == NULL)
{
/* Init the error with the string value of errno */
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
/* Return if we have a problem */
return NULL;
}
/* Attention!! Achtung!! This is a data pointer copy, */
/* not copying an object. That means that YOU the user */
/* of this API MUST allocate it yourself */
/* And, of course, YOU must delete it as well!! */
node->data = data;
/* Attach up our nodes */
node->next = next;
node->prev = prev;
/* Return the new node */
return node;
}
J2KAPI(j2k_Reader*) j2k_Reader_open(const char *fname, nrt_Error *error)
{
j2k_Reader *reader = NULL;
nrt_IOInterface *io = NULL;
if (!fname)
{
nrt_Error_init(error, "NULL filename", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
goto CATCH_ERROR;
}
if (!(io = nrt_IOHandleAdapter_open(fname, NRT_ACCESS_READONLY,
NRT_OPEN_EXISTING, error)))
goto CATCH_ERROR;
if (!(reader = j2k_Reader_openIO(io, error)))
goto CATCH_ERROR;
((OpenJPEGReaderImpl*) reader->data)->ownIO = 1;
return reader;
CATCH_ERROR:
{
if (io)
nrt_IOInterface_destruct(&io);
if (reader)
j2k_Reader_destruct(&reader);
return NULL;
}
}
OpenJPEGWriter_write(J2K_USER_DATA *data, nrt_IOInterface *io, nrt_Error *error)
{
OpenJPEGWriterImpl *impl = (OpenJPEGWriterImpl*) data;
NRT_BOOL rc = NRT_SUCCESS;
size_t compressedSize;
memset(error->message, 0, NRT_MAX_EMESSAGE);
if(!opj_set_error_handler(impl->codec,
OpenJPEG_errorHandler,
error))
{
nrt_Error_init(error, "Unable to set OpenJPEG error handler", NRT_CTXT,
NRT_ERR_UNK);
goto CATCH_ERROR;
}
if (!opj_end_compress(impl->codec, impl->stream))
{
/*nrt_Error_init(error, "Error ending compression", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);*/
goto CATCH_ERROR;
}
/* just copy/write the compressed data to the output IO */
compressedSize = (size_t)nrt_IOInterface_tell(impl->compressed, error);
if (!nrt_IOInterface_write(io, impl->compressedBuf, compressedSize, error))
{
nrt_Error_init(error, "Error writing data", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
goto CATCH_ERROR;
}
goto CLEANUP;
CATCH_ERROR:
{
rc = NRT_FAILURE;
}
CLEANUP:
{
}
return rc;
}
J2KAPI(j2k_Writer*) j2k_Writer_construct(j2k_Container *container,
j2k_WriterOptions *writerOps,
nrt_Error *error)
{
j2k_Writer *writer = NULL;
OpenJPEGWriterImpl *impl = NULL;
writer = (j2k_Writer*) J2K_MALLOC(sizeof(j2k_Container));
if (!writer)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(writer, 0, sizeof(j2k_Writer));
/* create the Writer interface */
impl = (OpenJPEGWriterImpl *) J2K_MALLOC(sizeof(OpenJPEGWriterImpl));
if (!impl)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT, NRT_ERR_MEMORY);
goto CATCH_ERROR;
}
memset(impl, 0, sizeof(OpenJPEGWriterImpl));
impl->container = container;
if (!(OpenJPEG_initImage(impl, writerOps, error)))
{
goto CATCH_ERROR;
}
writer->data = impl;
writer->iface = &WriterInterface;
return writer;
CATCH_ERROR:
{
if (writer)
{
j2k_Writer_destruct(&writer);
}
return NULL;
}
}
J2KPRIV(void) OpenJPEG_errorHandler(const char* msg, void* data)
{
nrt_Error* error = (nrt_Error*)data;
/* Initialize the first message, otherwise the message will be
overridden up the stack */
if(strlen(error->message) == 0)
{
nrt_Error_init(error, msg, NRT_CTXT, NRT_ERR_INVALID_OBJECT);
}
}
NRTAPI(nrt_Off) nrt_IOHandle_getSize(nrt_IOHandle handle, nrt_Error * error)
{
struct stat buf;
int rval = fstat(handle, &buf);
if (rval == -1)
{
nrt_Error_init(error, strerror(errno), NRT_CTXT, NRT_ERR_STAT_FILE);
return rval;
}
return buf.st_size;
}
NRTAPI(nrt_Off) nrt_IOHandle_seek(nrt_IOHandle handle, nrt_Off offset,
int whence, nrt_Error * error)
{
nrt_Off off = lseek(handle, offset, whence);
if (off == (nrt_Off) - 1)
{
nrt_Error_init(error, strerror(errno), NRT_CTXT,
NRT_ERR_SEEKING_IN_FILE);
}
return off;
}
Container_getComponent(J2K_USER_DATA *data, nrt_Uint32 idx, nrt_Error *error)
{
ContainerImpl *impl = (ContainerImpl*) data;
if (idx >= impl->nComponents)
{
nrt_Error_init(error, "Invalid component index",
NRT_CTXT, NRT_ERR_INVALID_OBJECT);
return NULL;
}
return impl->components[idx];
}
NRTAPI(NRT_BOOL) nrt_IOHandle_read(nrt_IOHandle handle, char *buf, size_t size,
nrt_Error * error)
{
static const DWORD MAX_READ_SIZE = (DWORD)-1;
size_t bytesRead = 0;
size_t bytesRemaining = size;
while (bytesRead < size)
{
/* Determine how many bytes to read */
const DWORD bytesToRead = (bytesRemaining > MAX_READ_SIZE) ?
MAX_READ_SIZE : (DWORD)bytesRemaining;
/* Read from file */
DWORD bytesThisRead = 0;
if (!ReadFile(handle,
buf + bytesRead,
bytesToRead,
&bytesThisRead,
NULL))
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
else if (bytesThisRead == 0)
{
// ReadFile does not fail when finding the EOF --
// instead it reports 0 bytes read, so this stops an infinite loop
// from Unexpected EOF
nrt_Error_init(error, "Unexpected end of file", NRT_CTXT,
NRT_ERR_READING_FROM_FILE);
return NRT_FAILURE;
}
bytesRead += bytesThisRead;
bytesRemaining -= bytesThisRead;
}
return NRT_SUCCESS;
}
NRTAPI(NRT_DLL_FUNCTION_PTR) nrt_DLL_retrieve(nrt_DLL * dll,
const char *function,
nrt_Error * error)
{
if (dll->lib)
{
NRT_DLL_FUNCTION_PTR ptr = dlsym(dll->lib, function);
if (ptr == (NRT_DLL_FUNCTION_PTR) NULL)
{
/* Problem if you couldnt produce the function */
nrt_Error_init(error, dlerror(), NRT_CTXT,
NRT_ERR_RETRIEVING_DLL_HOOK);
}
return ptr;
}
/* You shouldnt be calling it if it didnt load */
nrt_Error_init(error, dlerror(), NRT_CTXT, NRT_ERR_UNINITIALIZED_DLL_READ);
return (NRT_DLL_FUNCTION_PTR) NULL;
}
NRTAPI(nrt_DLL *) nrt_DLL_construct(nrt_Error * error)
{
nrt_DLL *dll = (nrt_DLL *) NRT_MALLOC(sizeof(nrt_DLL));
if (!dll)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
}
dll->libname = NULL;
dll->lib = NULL;
return dll;
}
NRTAPI(NRT_BOOL) nrt_DLL_load(nrt_DLL * dll, const char *libname,
nrt_Error * error)
{
dll->libname = (char *) NRT_MALLOC(strlen(libname) + 1);
if (!dll->libname)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NRT_FAILURE;
}
strcpy(dll->libname, libname);
dll->lib = dlopen(libname, RTLD_LAZY);
if (!dll->lib)
{
nrt_Error_init(error, dlerror(), NRT_CTXT, NRT_ERR_LOADING_DLL);
NRT_FREE(dll->libname);
dll->libname = NULL;
return NRT_FAILURE;
}
return NRT_SUCCESS;
}
NRTPROT(nrt_IntStack *) nrt_IntStack_construct(nrt_Error * error)
{
nrt_IntStack *stk = (nrt_IntStack *) NRT_MALLOC(sizeof(nrt_IntStack));
if (!stk)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NULL;
}
stk->sp = -1;
return stk;
}
NRTAPI(nrt_DateTime *) nrt_DateTime_fromString(const char *string,
const char *format,
nrt_Error * error)
{
struct tm t;
nrt_DateTime *dateTime = NULL;
double millis = 0.0;
/* NOTE: _NRT_strptime() does not use the tm_isdst flag at all. */
t.tm_isdst = -1;
if (!_NRT_strptime(string, format, &t, &millis))
{
nrt_Error_initf(error, NRT_CTXT, NRT_ERR_INVALID_OBJECT,
"Unknown error caused by the call to strptime with string [%s] and format string [%s]",
string, format);
return NULL;
}
/* Create a DateTime object */
dateTime = (nrt_DateTime *) NRT_MALLOC(sizeof(nrt_DateTime));
if (!dateTime)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NULL;
}
/* Initialize it from the tm struct
* TODO: Update _NRT_strptime() to just use a DateTime directly */
dateTime->year = t.tm_year + 1900;
/* 0-based so add 1 */
dateTime->month = t.tm_mon + 1;
dateTime->dayOfMonth = t.tm_mday;
dateTime->dayOfWeek = t.tm_wday + 1;
dateTime->dayOfYear = t.tm_yday + 1;
dateTime->hour = t.tm_hour;
dateTime->minute = t.tm_min;
dateTime->second = t.tm_sec + millis / 1000.0;
/* Compute the # of milliseconds */
if (!nrt_DateTime_updateMillis(dateTime, error))
{
NRT_FREE(dateTime);
return NULL;
}
return dateTime;
}
NRT_BOOL CustomIO::adapterClose(NRT_DATA* data,
nrt_Error* error)
{
if (data)
{
try
{
reinterpret_cast<CustomIO*>(data)->closeImpl();
return NRT_SUCCESS;
}
catch (const except::Exception& ex)
{
nrt_Error_init(error, ex.getMessage().c_str(), NRT_CTXT,
NRT_ERR_UNK);
return NRT_FAILURE;
}
catch (const std::exception& ex)
{
nrt_Error_init(error, ex.what(), NRT_CTXT,
NRT_ERR_UNK);
return NRT_FAILURE;
}
catch (...)
{
nrt_Error_init(error, "Unknown error", NRT_CTXT,
NRT_ERR_UNK);
return NRT_FAILURE;
}
}
else
{
// See destructor for why this is needed
nrt_Error_init(error, "Handle is NULL", NRT_CTXT,
NRT_ERR_INVALID_OBJECT);
return NRT_FAILURE;
}
}
NRTAPI(nrt_List *) nrt_List_construct(nrt_Error * error)
{
/* New allocate a list */
nrt_List *l;
l = (nrt_List *) NRT_MALLOC(sizeof(nrt_List));
if (!l)
{
/* Initialize the error and return NULL */
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NULL;
}
/* Null-initialize the link pointers */
l->first = l->last = NULL;
return l;
}
NRTAPI(nrt_DateTime *) nrt_DateTime_fromMillis(double millis, nrt_Error * error)
{
nrt_DateTime *dt = NULL;
dt = (nrt_DateTime *) NRT_MALLOC(sizeof(nrt_DateTime));
if (!dt)
{
nrt_Error_init(error, NRT_STRERROR(NRT_ERRNO), NRT_CTXT,
NRT_ERR_MEMORY);
return NULL;
}
nrt_DateTime_setTimeInMillis(dt, millis, error);
return dt;
}
NRTAPI(nrt_IOHandle) nrt_IOHandle_create(const char *fname,
nrt_AccessFlags access,
nrt_CreationFlags creation,
nrt_Error * error)
{
int fd;
if (access & NRT_ACCESS_WRITEONLY)
creation |= NRT_TRUNCATE;
fd = open(fname, access | creation, NRT_DEFAULT_PERM);
if (fd == -1)
{
nrt_Error_init(error, strerror(errno), NRT_CTXT, NRT_ERR_OPENING_FILE);
}
return fd;
}