RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://github.com/random-access-storage/random-access-storage below:

random-access-storage/random-access-storage: Easily make random-access-storage instances

Easily make random-access-storage instances

npm install random-access-storage

A random-access-storage instance is a common interface for a storage abstraction, that provides the following core api.

read(offset, size) - Read a buffer at a custom offset.
write(offset, data) - Write a buffer to a custom offset.
del(offset, size) - Delete data at a custom offset.

This module exposes a base class that implements most of the plumbing and flow you'd usually want to implement when making one.

const RandomAccessStorage = require('random-access-storage')
const fs = require('fs')

const file = fileReader('index.js')

file.read(0, 10, (err, buf) => console.log('0-10: ' + buf.toString()))
file.read(40, 15, (err, buf) => console.log('40-55: ' + buf.toString()))
file.close()

function fileReader (name) {
  let fd = 0
  return new RandomAccessStorage({
    open: function (req) {
      // called once automatically before the first read call
      fs.open(name, 'r', function (err, res) {
        if (err) return req.callback(err)
        fd = res
        req.callback(null)
      })
    },
    read: function (req) {
      const buf = Buffer.allocUnsafe(req.size)
      fs.read(fd, buf, 0, buf.length, req.offset, function (err, read) {
        if (err) return req.callback(err)
        if (read < buf.length) return req.callback(new Error('Could not read'))
        req.callback(null, buf)
      })
    },
    close: function (req) {
      if (!fd) return req.callback(null)
      fs.close(fd, err => req.callback(err))
    }
  })
}

const storage = new RandomAccessStorage([options])

Make a new instance. Options include:

{
  createAlways: false, // always create storage on first open
  open: fn, // sets ._open
  read: fn, // sets ._read
  write: fn, // sets ._write
  del: fn, // sets ._del
  truncate: fn, // sets ._truncate
  stat: fn, // sets ._stat
  suspend: fn, // sets ._suspend
  close: fn, // sets ._close
  unlink: fn // sets ._unlink
}

True if the storage implements ._read.

True if the storage implements ._write.

True if the storage implements ._del.

True if the storage implements ._truncate.

True if the storage implements ._stat.

True if the storage has been fully opened.

True if the storage has been fully closed.

True if the storage has been fully unlinked.

True if the storage is currently being written to.

Emitted when the storage is fully open.

Emitted when the storage is fully closed.

Emitted when the storage is fully unlinked.

Emitted when the storage is fully suspended

Emitted when the storage comes out of suspension.

Explicitly open the storage. If you do not call this yourself, it will automatically called before any read/write/del/stat operation.

It is safe to call this more than once.

Triggers one call to _open if you implement that.

Implement storage open.

req.create is true if the storage should be created.

Call req.callback when it is fully opened.

storage.read(offset, size, callback)

Read the specified bytes from the storage at the specified byte offset. Calls the callback with a (err, buffer).

Implement storage read.

req.offset contains the byte offset you should read at.
req.size contains the amount of bytes you should read.

Call req.callback(err, buffer) when the read is completed.