sample TPIE filestream test

100%

sample TPIE filestream test

✓ Published0🌍 Public

Last edited Feb 13, 2016

Created on Feb 13, 2016

This example demonstrates the basic file-stream operations of the TPIE library through a small C++ program. It writes ten 3D segment structs to a file, copies that file to a second stream, and then reads the copy back, printing each item’s coordinates and the stream size. The code initializes TPIE’s memory manager and stream subsystems, sets a 50 MB memory limit, and uses `tpie::file_stream` with `write`, `read`, and `can_read` methods for sequential I/O. The output shows the original and copied data in text form.

AI-generated description

Creating a simple file I/O app using TPIE

importing tpie/tpie.h and initializing tpie subsystems for

memory and streams are required

set desired memory limit

populate data using write_stream

use the TPIE interfaces to copy one tpie stream to another

test copy by reading copied file

tear down tpie subsystems with finish

Similar vizzes

Loading thumbnail…

Gist 598a74e0cb4c65102232

This example demonstrates a C++ program that first simulates traversal and deletion of nodes in a singly linked list, printing the values as it moves and removes each node, and then reads a board from the file `board.txt` into a 2D vector of characters. The rendering shows the board as a grid, printing each cell with its indices and value, and then updates two specific positions to display a modified board. The code relies on standard C++ libraries such as `<iostream>`, `<fstream>`, and `<vector>`, with no external visualization APIs.

NN0taN3rd

49% match

Loading thumbnail…

Using sendfile(2) with NodeJS

This example demonstrates using the `sendfile(2)` system call in NodeJS to stream file contents over a TCP connection, bypassing userspace buffering for efficiency. It creates a net server that opens a file with `process.binding('fs').open` and sends data in chunks via `sendfile`, tracking the file offset across invocations. The code handles `EAGAIN` errors by listening for the `'drain'` event and manually starting the socket’s `_writeWatcher` to resume transmission, ultimately ending the connection when the file is fully sent. The file path and port are supplied as command-line arguments.

Aalessioalex

49% match

Loading thumbnail…

TINTIN Loading and Parsing CSV Data

This example demonstrates how to load and parse a CSV file using D3.js, displaying a summary of the data's dimensions and size. It fetches a remote CSV file containing CSS named colors, parses it with `d3.csv`, and reports the row count, column count, and file size in kilobytes. The output is rendered as large text within a `<pre>` element using `textContent`, and the file size is calculated by measuring the formatted string length with `d3.csvFormat`. The code relies on the Fetch API to retrieve the raw text from a GitHub Gist URL.

Ppnlinyz

46% match

Loading thumbnail…

d3.tsv

This example demonstrates loading and plotting tab-separated values from an external TSV file using the D3.js library. The chart displays five data points as circles on a simple scatterplot, with linear scales mapping x and y coordinates to SVG positions. The code uses the `d3.tsv` method to fetch and parse the file, then converts string values to numbers with the unary plus operator. Axes are rendered via `d3.svg.axis`, and the SVG circles are appended with the `.point` class, showing basic data parsing and visualization in a minimal setup.

Mmbostock

46% match

Loading thumbnail…

Gist 40a7b304a32e2e0db885

This example visualizes a peg-based board game using C++ with standard libraries including iostream, fstream, vector, and unordered_map. It defines classes for pegs, board spots, and players, tracking movement through a pegMove structure with coordinates and begin/end flags. The code renders board positions as characters and supports multiple peg colors (blue, green, red, big blue) with distinct identifiers. It demonstrates object-oriented design for game state management, including move tracking, occupancy checks, and position resets, though it does not include any graphics or plotting libraries, appearing to be a logical simulation rather than a visual data display.

NN0taN3rd

46% match

Loading thumbnail…

Parallel

This example shows how GNU Parallel distributes the processing of a large text file across multiple CPU cores. The visualization maps the input stream through a pipeline, highlighting the chunks that match the pattern “foo” as they are filtered by the `grep` command. The code uses the `parallel` command with `--pipe --block 2M` to split the data into 2-megabyte blocks, which are then processed concurrently. The rendering displays the block boundaries and matches in real time, using a simple custom canvas-based layout to depict the file’s contents and the parallel task execution.

Aant1j

46% match

Loading thumbnail…

Gist 474c05b31ba635a5938112a1efb5e7ef

This example demonstrates reading a file from disk using Node.js’s synchronous file system APIs, specifically `fs.openSync`, `fs.readSync`, and `fs.closeSync`. It reads the first 4 KB chunk of `public/index.html` into a `Buffer`, converts that slice to a UTF-8 string, and prints it to the console. The code also includes a commented-out asynchronous equivalent using `fs.open`, `fs.read`, and `fs.close`, showing both approaches side by side.

Aalessioalex

46% match

Loading thumbnail…

Fork of Loading and Parsing CSV Data (TaiBif)

This example displays a concise summary of a CSV dataset loaded from a GitHub gist containing TaiBif occurrence records. The page shows three numeric metrics: the file size in kilobytes, the total row count, and the number of columns, rendered in large text. It uses D3 v5's `d3.csv` promise-based method to fetch and parse the data, then `d3.csvFormat` to calculate the byte length. The code also includes commented-out alternatives using the Fetch API with `async`/`await` and `d3.csvParse`.

Yyungchiau

45% match