Services for byte streams and arrays

Introduced classes

interface BytePattern

core :: BytePattern

Any kind of entity which can be searched for in a Sequence of Byte
class Bytes

core :: Bytes

A buffer containing Byte-manipulation facilities

Redefined classes

redef extern class CString

core :: bytes $ CString

C string char *
redef abstract class FlatText

core :: bytes $ FlatText

All kinds of array-based text representations.
redef enum Int

core :: bytes $ Int

Native integer numbers.
redef class Sys

core :: bytes $ Sys

The main class of the program.
redef abstract class Text

core :: bytes $ Text

High-level abstraction for all text representations

All class definitions

interface BytePattern

core $ BytePattern

Any kind of entity which can be searched for in a Sequence of Byte
class Bytes

core $ Bytes

A buffer containing Byte-manipulation facilities
redef extern class CString

core :: bytes $ CString

C string char *
redef abstract class FlatText

core :: bytes $ FlatText

All kinds of array-based text representations.
redef enum Int

core :: bytes $ Int

Native integer numbers.
redef class Sys

core :: bytes $ Sys

The main class of the program.
redef abstract class Text

core :: bytes $ Text

High-level abstraction for all text representations
package_diagram core::bytes bytes core::flat flat core::bytes->core::flat core::abstract_text abstract_text core::flat->core::abstract_text ...core::abstract_text ... ...core::abstract_text->core::abstract_text core::codec_base codec_base core::codec_base->core::bytes core::utf8 utf8 core::utf8->core::codec_base core::iso8859_1 iso8859_1 core::iso8859_1->core::codec_base core::utf8... ... core::utf8...->core::utf8 core::iso8859_1... ... core::iso8859_1...->core::iso8859_1


module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters
module array

core :: array

This module introduces the standard array structure.
module circular_array

core :: circular_array

Efficient data structure to access both end of the sequence.
module collection

core :: collection

This module define several collection classes.
module fixed_ints

core :: fixed_ints

Basic integers of fixed-precision
module hash_collection

core :: hash_collection

Introduce HashMap and HashSet.
module kernel

core :: kernel

Most basic classes and methods.
module list

core :: list

This module handle double linked lists
module math

core :: math

Mathematical operations
module native

core :: native

Native structures for text and bytes
module range

core :: range

Module for range of discrete objects.
module sorter

core :: sorter

This module contains classes used to compare things and sorts arrays.
module union_find

core :: union_find

union–find algorithm using an efficient disjoint-set data structure


module flat

core :: flat

All the array-based text representations


module codec_base

core :: codec_base

Base for codecs to use with streams


module a_star

a_star :: a_star

A* pathfinding in graphs
module a_star-m


module abstract_tree

trees :: abstract_tree

Introduce tree structures abstraction
module activities

android :: activities

Android Activities wrapper
module actors

actors :: actors

Abstraction of the actors concepts
module agent_simulation

actors :: agent_simulation

a "Framework" to make Multi-Agent Simulations in Nit
module ai

ai :: ai

Simple toolkit for artificial intelligence.
module all

sdl2 :: all

Unites the main sdl2 module and its sister library sdl2::image
module android

android :: android

Android services and implementation of app.nit
module android19

gamnit :: android19

Variation using features from Android API 19
module angles

geometry :: angles

Angle related service using Float to represent an angle in radians
module api

github :: api

Nit object oriented interface to Github api.
module app

ios :: app

Basic structure for Nit apps on iOS
module app

app :: app

app.nit is a framework to create cross-platform applications
module app_base

app :: app_base

Base of the app.nit framework, defines App
module app_kit

cocoa :: app_kit

The Application Kit provides services to create GUI
module array_debug

array_debug :: array_debug

Exposes functions to help profile or debug Arrays.
module assets

android :: assets

Implementation of app::assets
module assets

app :: assets

Portable services to load resources from the assets folder
module assets

ios :: assets

Implementation of app::assets
module assets_and_resources

android :: assets_and_resources

Android Assets and Resources Management
module at_boot

android :: at_boot

Import this module to launch Service at device boot
module attributes

sax :: attributes

Interface for a list of XML attributes.
module attributes_impl

sax :: attributes_impl

Default implementation of the Attributes interface.
module audio

ios :: audio

iOS implementation of app::audio using AVAudioPlayer
module audio

android :: audio

Android audio services, wraps a part of android audio API
module audio

app :: audio

Services to load and play Sound and Music from the assets folder
module audio

linux :: audio

app::audio implementation for GNU/Linux using SDL2 mixer
module aware

android :: aware

Android compatibility module
module backtrack

ai :: backtrack

Basic framework for active backtrack solver
module base64

base64 :: base64

Offers the base 64 encoding and decoding algorithms
module basic_ciphers

crypto :: basic_ciphers

Basic cryptographic ciphers and utilities.
module bcm2835

bcm2835 :: bcm2835

Services to control the bcm2835 chipset used in the Raspberry Pi
module binary

binary :: binary

Read and write binary data with any Reader and Writer
module bintree

trees :: bintree

Binary Tree data-structure
module bitmap

bitmap :: bitmap

The Bitmap class represents a 24-bit bitmap image. An instance can be constructed
module bktree

trees :: bktree

Implementation of BKTree
module bmfont

gamnit :: bmfont

Parse Angel Code BMFont format and draw text
module bootstrap

html :: bootstrap

HTML templates for Bootstrap components.
module boxes

geometry :: boxes

Provides interfaces and classes to represent basic geometry needs.
module bucketed_game

bucketed_game :: bucketed_game

Game framework with an emphasis on efficient event coordination
module bundle

android :: bundle

A mapping class of String to various value types used by the
module bytes

crypto :: bytes

Mix of utilities and services related to bytes
module c

c :: c

Structures and services for compatibility with the C language
module cache

github :: cache

Enable caching on Github API accesses.
module caching

serialization :: caching

Services for caching serialization engines
module camera_control

gamnit :: camera_control

Simple camera control for user, as the method accept_scroll_and_zoom
module camera_control_android

gamnit :: camera_control_android

Two fingers camera manipulation, pinch to zoom and slide to scroll
module camera_control_linux

gamnit :: camera_control_linux

Mouse wheel and middle mouse button to control camera
module cameras

gamnit :: cameras

Camera services producing Model-View-Projection matrices
module cameras_cache

gamnit :: cameras_cache

Cache the Matrix produced by Camera::mvp_matrix
module cardboard

gamnit :: cardboard

Update the orientation of world_camera at each frame using the head position given by android::cardboard
module cardboard

android :: cardboard

Services from the Google Cardboard SDK for virtual reality on Android
module cartesian

cartesian :: cartesian

Memory-efficient Cartesian products on heterogeneous collections.
module chameneosredux

actors :: chameneosredux

Example implemented from "The computer Language Benchmarks Game" - Chameneos-Redux
module checker

dom :: checker

Simple XML validity checker using the dom module
module client

gamnit :: client

Client-side network services for games and such
module clusters

dot :: clusters

Example from
module cocoa

cocoa :: cocoa

Cocoa API, the development layer of OS X
module cocoa_extern_types

cocoa :: cocoa_extern_types

Test extern classes from the Cocoa framework and extern factories
module cocoa_message_box

cocoa :: cocoa_message_box

Simple message box using the Cocoa framework
module codecs

core :: codecs

Group module for all codec-related manipulations
module collections

java :: collections

Basic Java collections
module combinations

combinations :: combinations

Memory-efficient Cartesian products, combinations and permutation on collections.
module common

gamnit :: common

Services common to the client and server modules
module commonmark_gen

markdown2 :: commonmark_gen

Generate Nitunit tests from commonmark specification.
module concurrent_array_and_barrier

pthreads :: concurrent_array_and_barrier

A basic usage example of the modules pthreads and pthreads::cocurrent_collections
module concurrent_collections

pthreads :: concurrent_collections

Introduces thread-safe concurrent collections
module config

config :: config

Configuration options for nit tools and apps
module console

console :: console

Defines some ANSI Terminal Control Escape Sequences.
module content_handler

sax :: content_handler

Receives notification of the logical content of a document.
module core

core :: core

Standard classes and methods used by default by Nit programs and libraries.
module counter

counter :: counter

Simple numerical statistical analysis and presentation
module cpp

cpp :: cpp

Services for compatibility with C++ code and libraries
module crapto

crapto :: crapto

Cryptographic attacks and utilities.
module crypto

crypto :: crypto

Mix of all things cryptography-related
module csv

csv :: csv

CSV document handling.
module curl

curl :: curl

Data transfer powered by the native curl library
module curl_http

curl :: curl_http

Example use of the Curl module
module curl_json

neo4j :: curl_json

cURL requests compatible with the JSON REST APIs.
module curl_rest

curl :: curl_rest

module curses

curses :: curses

Curses for Nit
module custom_serialization

serialization :: custom_serialization

Example of an ad hoc serializer that is tailored to transform business specific objects into customized representation.
module dalvik

android :: dalvik

Java related services specific to Android and its Dalvik VM
module data_store

linux :: data_store

app::data_store implementation on GNU/Linux
module data_store

app :: data_store

Key/value storage services
module data_store

ios :: data_store

Implements app::data_store using NSUserDefaults
module data_store

android :: data_store

Implements app::data_store using shared_preferences
module date

date :: date

Services to manipulate Date, Time and DateTime
module decl_handler

sax :: decl_handler

SAX2 extension handler for DTD declaration events.
module decorators

markdown :: decorators

Decorators for markdown parsing.
module depth

gamnit :: depth

Framework for 3D games in Nit
module depth_core

gamnit :: depth_core

Base entities of the depth 3D game framework
module deriving

deriving :: deriving

Automatic derivable implementations of standard basic methods.
module digraph

graph :: digraph

Implementation of directed graphs, also called digraphs.
module display

gamnit :: display

Abstract display services
module display_android

gamnit :: display_android

Gamnit display implementation for Android
module display_ios

gamnit :: display_ios

Gamnit display implementation for iOS
module display_linux

gamnit :: display_linux

Gamnit display implementation for GNU/Linux using egl, sdl and x11
module dom

dom :: dom

Easy XML DOM parser
module dot

dot :: dot

Dot rendering library
module drop_privileges

privileges :: drop_privileges

Example using the privileges module to drop privileges from root
module dtd_handler

sax :: dtd_handler

Receives notification of basic DTD-related events.
module dynamic

json :: dynamic

Dynamic interface to read values from JSON strings
module dynamic_resolution

gamnit :: dynamic_resolution

Virtual screen with a resolution independent from the real screen
module egl

gamnit :: egl

Use of EGL to implement Gamnit on GNU/Linux and Android
module egl

egl :: egl

Interface between rendering APIs (OpenGL, OpenGL ES, etc.) and the native windowing system.
module emscripten

emscripten :: emscripten

Platform for the emscripten framework
module engine_tools

serialization :: engine_tools

Advanced services for serialization engines
module english_utils

crapto :: english_utils

English language utilities for cryptographic purposes.
module entity_resolver

sax :: entity_resolver

Basic interface for resolving entities.
module environ

core :: environ

Access to the environment variables of the process
module error

json :: error

Intro JsonParseError which is exposed by all JSON reading APIs
module error

neo4j :: error

Errors thrown by the neo4j library.
module error_handler

sax :: error_handler

Basic interface for SAX error handlers.
module event_queue

event_queue :: event_queue

Register, update and discard events in a timeline.
module events

github :: events

Events are emitted by Github Hooks.
module events

sdl2 :: events

SDL 2 events and related services
module example_angular

popcorn :: example_angular

This is an example of how to use angular.js with popcorn
module example_vsm

vsm :: example_vsm

Example using a FileIndex
module exec

core :: exec

Invocation and management of operating system sub-processes.
module ext

msgpack :: ext

Application specific MessagePack extension MsgPackExt
module ext

posix :: ext

Services not defined in POSIX but provided by most implementations
module ext

sax :: ext

Interfaces to optional SAX2 handlers.
module extra

pthreads :: extra

Offers some POSIX threads services that are not available on all platforms
module extra

curl :: extra

Shortcut services for scripts: http_get and http_download
module fannkuchredux

actors :: fannkuchredux

Example implemented from "The computer Language Benchmarks Game" - Fannkuch-Redux
module fca

fca :: fca

Formal Concept Analysis
module ffi_support

java :: ffi_support

Core supporting services for the FFI with Java
module file

core :: file

File manipulations (create, read, write, etc.)
module file_server

nitcorn :: file_server

Provides the FileServer action, which is a standard and minimal file server
module flat

gamnit :: flat

Simple API for 2D games, built around Sprite and App::update
module flat_core

gamnit :: flat_core

Core services for the flat API for 2D games
module font

gamnit :: font

Abstract font drawing services, implemented by bmfont and tileset
module for_abuse

for_abuse :: for_abuse

Service management through the for control structure.
module foundation

cocoa :: foundation

The Foundation Kit provides basic Objective-C classes and structures
module functional

functional :: functional

Functional types and functional API for Iterator
module functional_gen

functional :: functional_gen

This module is only used to generate functional_types.nit
module functional_types

functional :: functional_types

This module provides functional type to represents various function forms.
module game

android :: game

Android services and implementation of app.nit for gamnit and mnit
module gamepad

android :: gamepad

Support for gamepad events (over Bluetooth or USB)
module gamnit

gamnit :: gamnit

Game and multimedia framework for Nit
module gamnit_android

gamnit :: gamnit_android

Support services for Gamnit on Android
module gamnit_ios

gamnit :: gamnit_ios

Support services for gamnit on iOS
module gamnit_linux

gamnit :: gamnit_linux

Support services for Gamnit on GNU/Linux
module gdk

gtk :: gdk

Services from GDK
module gdk_enums

gtk :: gdk_enums

module gen_nit

gen_nit :: gen_nit

Support to generate and otherwise manipulate Nit code
module geometry

geometry :: geometry

Provides interfaces and classes to represent basic geometry needs.
module gettext

gettext :: gettext

Internationalization of Strings using gettext library
module github

github :: github

Nit wrapper for Github API
module glesv2

glesv2 :: glesv2

OpenGL graphics rendering library for embedded systems, version 2.0
module glkit

ios :: glkit

GLKit services to create an OpenGL ES context on iOS
module gmp

gmp :: gmp

Multi precision integer and rational number using gmp lib
module graph

neo4j :: graph

Provides an interface for services on a Neo4j graphs.
module gtk

gtk :: gtk

GTK+ widgets and services
module gtk_core

gtk :: gtk_core

Classes and services to use libGTK widgets
module gtk_enums

gtk :: gtk_enums

module hash_debug

hash_debug :: hash_debug

Inject behavior analysis to hash-collections (HashMap, HashSet, etc.)
module hello

dot :: hello

Example from
module hello_cocoa

cocoa :: hello_cocoa

Hello world using the Cocoa framework
module hello_ios

ios :: hello_ios

Simple iOS app with a single label
module helpers

sax :: helpers

Contains "helper" classes, including support for bootstrapping SAX-based applications.
module hooks

github :: hooks

Github hook event listening with nitcorn.
module htcpcp_server

nitcorn :: htcpcp_server

A server that implements HTCPCP. At the moment there are no additions.
module html

html :: html

HTML output facilities
module html_page

html :: html_page

module http_errors

nitcorn :: http_errors

Offers ErrorTemplate to display error pages
module http_request

ios :: http_request

Implementation of app::http_request for iOS
module http_request

nitcorn :: http_request

Provides the HttpRequest class and services to create it
module http_request

android :: http_request

Android implementation of app:http_request
module http_request

app :: http_request

HTTP request services: AsyncHttpRequest and Text::http_get
module http_request

linux :: http_request

Implementation of app::http_request using GDK and Curl
module http_request_buffer

nitcorn :: http_request_buffer

Http request parsing for buffered inputs.
module http_request_example

app :: http_request_example

Example for the app::http_request main service AsyncHttpRequest
module http_response

nitcorn :: http_response

Provides the HttpResponse class and http_status_codes
module image

sdl2 :: image

Services of the SDL_image 2.0 library
module ini

ini :: ini

Read and write INI configuration files
module input

mnit :: input

Defines abstract classes for user and general inputs to the application.
module input

bcm2835 :: input

module input_events

android :: input_events

Pointer and hardware key events
module input_ios

gamnit :: input_ios

Gamnit event support for iOS
module input_source

sax :: input_source

A single input source for an XML entity.
module inspect

serialization :: inspect

Refine Serializable::inspect to show more useful information
module intent

android :: intent

Services allowing to launch activities and start/stop services using
module intent_api10

android :: intent_api10

Services allowing to launch activities and start/stop services using
module intent_api11

android :: intent_api11

Refines intent module to add API 11 services
module intent_api12

android :: intent_api12

Refines intent module to add API 12 services
module intent_api14

android :: intent_api14

Refines intent module to add API 14 services
module intent_api15

android :: intent_api15

Refines intent module to add API 15 services
module intent_api16

android :: intent_api16

Refines intent module to add API 16 services
module intent_api17

android :: intent_api17

Refines intent module to add API 17 services
module intent_api18

android :: intent_api18

Refines intent module to add API 18 services
module intent_api19

android :: intent_api19

Refines intent module to add API 19 services
module io

java :: io

Services from the package
module ios

ios :: ios

iOS platform support
module iso8859_1

core :: iso8859_1

Codec for ISO8859-1 I/O
module iter_extras

functional :: iter_extras

This modules provides a new functional interface for Iterator.
module java

java :: java

Supporting services for the FFI with Java and to access Java libraries
module jointask_example

pthreads :: jointask_example

Simple example of joinable task using threadpool
module json

json :: json

Read and write JSON formatted text using the standard serialization services
module json_graph_store

neo4j :: json_graph_store

Provides JSON as a mean to store graphs.
module jvm

jvm :: jvm

Java Virtual Machine invocation API and others services from the JNI C API
module keys

gamnit :: keys

Simple service keeping track of which keys are currently pressed
module landscape

gamnit :: landscape

Lock the application in the landscape orientation
module landscape

android :: landscape

Lock the application in the landscape orientation
module langannot

gettext :: langannot

Sample module showing the use of the i18n annotation
module lexer

saxophonit :: lexer

SAXophoNit’s lexer
module lexical_handler

sax :: lexical_handler

SAX2 extension handler for lexical events.
module lexpr

logic :: lexpr

Logical expression.
module libevent

libevent :: libevent

Low-level wrapper around the libevent library to manage events on file descriptors
module libevent_example

libevent :: libevent_example

Minimal usage example of libevent
module limit_fps

gamnit :: limit_fps

Frame-rate control for applications
module linux

linux :: linux

Implementation of app.nit for the Linux platform
module load_image

android :: load_image

Low-level services to load pixel data from the assets
module loader

github :: loader

module log

android :: log

Advanced Android logging services
module log

nitcorn :: log

Services inserting a timestamp in all prints and to log each requests
module logger

logger :: logger

A simple logger for Nit
module logic

logic :: logic

First-order logic data structure and algorithm.
module macro

template :: macro

String templating using macros.
module man

markdown :: man

Simple groff decorator restricted for manpages.
module mandelbrot

actors :: mandelbrot

Example implemented from "The computer Language Benchmarks Game" - Mandelbrot
module markdown

markdown :: markdown

Markdown parsing.
module markdown_ast

markdown2 :: markdown_ast

Markdown AST representation
module markdown_block_parsing

markdown2 :: markdown_block_parsing

Markdown blocks parsing
module markdown_github

markdown2 :: markdown_github

Markdown Github mode
module markdown_html_rendering

markdown2 :: markdown_html_rendering

HTML rendering of Markdown documents
module markdown_inline_parsing

markdown2 :: markdown_inline_parsing

Parser for inline markdown
module markdown_latex_rendering

markdown2 :: markdown_latex_rendering

LaTeX rendering of Markdown documents
module markdown_man_rendering

markdown2 :: markdown_man_rendering

Manpages rendering of Markdown documents
module markdown_md_rendering

markdown2 :: markdown_md_rendering

Markdown rendering of Markdown documents
module markdown_rendering

markdown2 :: markdown_rendering

Markdown document rendering
module matrix

matrix :: matrix

Services for matrices of Float values
module md5

md5 :: md5

Native MD5 digest implementation as Text::md5
module media_types

nitcorn :: media_types

Services to identify Internet media types (or MIME types, Content-types)
module meta

meta :: meta

Simple user-defined meta-level to manipulate types of instances as object.
module minimal

sdl2 :: minimal

An example to test and demonstrate the sdl2 lib with image and events
module mixer

sdl2 :: mixer

SDL2 mixer with sample/sounds and music
module model_dimensions

gamnit :: model_dimensions

Dimensions related services for Model and Mesh
module model_parser_base

gamnit :: model_parser_base

Services to parse models from a text description
module mongodb

mongodb :: mongodb

MongoDB Nit Driver.
module more_collections

more_collections :: more_collections

Highly specific, but useful, collections-related classes.
module more_lights

gamnit :: more_lights

More implementations of Light
module more_materials

gamnit :: more_materials

Various material implementations
module more_meshes

gamnit :: more_meshes

More simple geometric meshes
module more_models

gamnit :: more_models

Services to load models from the assets folder
module mpd

mpd :: mpd

Music Player Daemon client library
module mpi

mpi :: mpi

Implementation of the Message Passing Interface protocol by wrapping OpenMPI
module msgpack

msgpack :: msgpack

MessagePack, an efficient binary serialization format
module msgpack_to_json

msgpack :: msgpack_to_json

Convert MessagePack format to JSON
module mtl

gamnit :: mtl

Services to parse .mtl material files
module namespace_support

sax :: namespace_support

Encapsulates Namespace logic for use by applications using SAX, or internally by SAX drivers.
module native_app_glue

android :: native_app_glue

Wrapper of the Android native_app_glue framework to implement app.nit
module native_curl

curl :: native_curl

Binding of C libCurl which allow us to interact with network.
module native_gmp

gmp :: native_gmp

Low-level GMP features
module native_mongodb

mongodb :: native_mongodb

Native wrapper for the MongoDB C Driver
module native_notification

android :: native_notification

Native Java classes for notifications
module native_postgres

postgresql :: native_postgres

A native wrapper ove the postgres c api
module native_sqlite3

sqlite3 :: native_sqlite3

Low-level Sqlite3 features
module native_ui

android :: native_ui

Native services from the android.view and android.widget namespaces
module neo4j

neo4j :: neo4j

Neo4j connector through its JSON REST API using curl.
module network

gamnit :: network

Easy client/server logic for games and simple distributed applications
module nit_activity

android :: nit_activity

Core implementation of app.nit on Android using a custom Java entry point
module nitcc_runtime

nitcc_runtime :: nitcc_runtime

Runtime library required by parsers and lexers generated by nitcc
module nitcorn

nitcorn :: nitcorn

The nitcorn Web server framework creates server-side Web apps in Nit
module nitcorn_hello_world

nitcorn :: nitcorn_hello_world

Hello World Web server example
module nitcorn_reverse_proxy

nitcorn :: nitcorn_reverse_proxy

Minimal example using a ProxyAction
module niti_runtime

niti_runtime :: niti_runtime

Runtime library to loop around the main program for each line in file-name arguments
module nitmd

markdown2 :: nitmd

A Markdown parser for Nit.
module nitmd

markdown :: nitmd

A Markdown parser for Nit.
module nlp

nlp :: nlp

Natural Language Processor based on the StanfordNLP core.
module nlp_index

nlp :: nlp_index

Example showing how to use a NLPFileIndex.
module noise

noise :: noise

Noise generators PerlinNoise and InterpolatedNoise
module notification

android :: notification

Services to show notification in the Android status bar
module obj

gamnit :: obj

Services to parse .obj geometry files
module opengles2_hello_triangle

glesv2 :: opengles2_hello_triangle

Basic example of OpenGL ES 2.0 usage using SDL 2
module opts

opts :: opts

Management of options on the command line
module ordered_tree

ordered_tree :: ordered_tree

Manipulation and presentation of ordered trees.
module pagerank

graph :: pagerank

Add PageRank computation for vertices in Digraph.
module parser

dom :: parser

XML DOM-parsing facilities
module parser_base

parser_base :: parser_base

Simple base for hand-made parsers of all kinds
module particles

gamnit :: particles

Particle effects
module perfect_hashing

perfect_hashing :: perfect_hashing

Perfect hashing and perfect numbering
module performance_analysis

performance_analysis :: performance_analysis

Services to gather information on the performance of events by categories
module pipeline

pipeline :: pipeline

Pipelined filters and operations on iterators.
module platform

ios :: platform

Triggers compilation for the iOS platform
module platform

android :: platform

Triggers compilation for the android platform
module points_and_lines

geometry :: points_and_lines

Interfaces and classes to represent basic geometry needs.
module polygon

geometry :: polygon

Convex Polygons manipulations
module pop_auth

popcorn :: pop_auth

Authentification handlers.
module pop_config

popcorn :: pop_config

Configuration file and options for Popcorn apps
module pop_handlers

popcorn :: pop_handlers

Route handlers.
module pop_json

popcorn :: pop_json

Introduce useful services for JSON REST API handlers.
module pop_repos

popcorn :: pop_repos

Repositories for data management.
module pop_routes

popcorn :: pop_routes

Internal routes representation.
module pop_sessions

popcorn :: pop_sessions

Session handlers
module pop_tasks

popcorn :: pop_tasks

Popcorn threaded tasks
module pop_templates

popcorn :: pop_templates

Template rendering for popcorn
module pop_tests

popcorn :: pop_tests

Popcorn testing services
module pop_validation

popcorn :: pop_validation

Quick and easy validation framework for Json inputs
module popcorn

popcorn :: popcorn

Application server abstraction on top of nitcorn.
module portrait

gamnit :: portrait

Lock the application in the portrait orientation
module portrait

android :: portrait

Config to set the portrait orientation
module poset

poset :: poset

Pre order sets and partial order set (ie hierarchies)
module posix

posix :: posix

Services conforming to POSIX
module postgres

postgresql :: postgres

Services to manipulate a Postgres database
module privileges

privileges :: privileges

Process privileges management utilities
module programs

gamnit :: programs

Services for graphical programs with shaders, attributes and uniforms
module progression

progression :: progression

Event-based interface to track the progression of an operation.
module projection

matrix :: projection

Services on Matrix to transform and project 3D coordinates
module prompt

prompt :: prompt

Basic services to display a prompt
module protocol

core :: protocol

module proxy

nitcorn :: proxy

Provides the ProxyAction action, which redirects requests to another interface
module pthreads

nitcorn :: pthreads

Activate the use of pthreads with nitcorn
module pthreads

pthreads :: pthreads

Main POSIX threads support and intro the classes Thread, Mutex and Barrier
module puzzle

ai :: puzzle

The N-puzzle problem, modeled naively as a SearchProblem.
module quadtree

geometry :: quadtree

QuadTree API mostly used for 2 dimensional collision detection
module queens

ai :: queens

Example of the famous eight-queens problem solved with the ai::backtrack module.
module queries

mongodb :: queries

Mongo queries framework
module rbtree

trees :: rbtree

A red–black tree is a data structure which is a type of self-balancing binary search tree.
module reactor

nitcorn :: reactor

Core of the nitcorn project, provides HttpFactory and Action
module read

msgpack :: read

Low-level read MessagePack format from Reader streams
module reader_model

saxophonit :: reader_model

Reader’s model.
module readline

readline :: readline

GNU readline library wrapper
module realtime

realtime :: realtime

Services to keep time of the wall clock time
module redef_collections

pthreads :: redef_collections

Redef some basic collections to be thread-safe
module restful

nitcorn :: restful

Support module for the nitrestful tool and the restful annotation
module restful_annot

nitcorn :: restful_annot

Example for the restful annotation documented at lib/nitcorn/restful.nit
module ropes_debug

ropes_debug :: ropes_debug

Exposes methods for debugging ropes when needed.
module rubix

rubix :: rubix

Rubix-cube modelization library
module safe

serialization :: safe

Services for safer deserialization engines
module sax

sax :: sax

Core SAX APIs.
module sax_locator

sax :: sax_locator

Interface for associating a SAX event with a document location.
module sax_locator_impl

sax :: sax_locator_impl

Provides an optional convenience implementation of Locator.
module sax_parse_exception

sax :: sax_parse_exception

Encapsulates an XML parse error or warning.
module saxophonit

saxophonit :: saxophonit

A SAX 2 parser in Nit.
module scene2d

scene2d :: scene2d

Framework for 2D management of game elements
module sdl2

sdl2 :: sdl2

Simple DirectMedia Layer (SDL) 2.0 services for easy window creation and 2D drawing
module sdl2_base

sdl2 :: sdl2_base

Basic SDL 2 features
module search

ai :: search

Basic framework for search problems and solver.
module selection

gamnit :: selection

Select Actor from a screen coordinate
module sendmail

sendmail :: sendmail

Send emails using the sendmail program
module sensors

android :: sensors

Access Android sensors
module sequential_id

neo4j :: sequential_id

Provides a sequential identification scheme for Neo4j nodes.
module serialization

serialization :: serialization

General serialization services
module serialization_common

msgpack :: serialization_common

Serialization services for serialization_write and serialization_read
module serialization_core

serialization :: serialization_core

Abstract services to serialize Nit objects to different formats
module serialization_read

json :: serialization_read

Services to read JSON: deserialize_json and JsonDeserializer
module serialization_read

msgpack :: serialization_read

Deserialize full Nit objects from MessagePack format
module serialization_write

msgpack :: serialization_write

Serialize full Nit objects to MessagePack format
module serialization_write

json :: serialization_write

Services to write Nit objects to JSON strings: serialize_to_json and JsonSerializer
module server

gamnit :: server

Server-side network services for games and such
module server_config

nitcorn :: server_config

Classes and services to configure the server
module service

android :: service

Android service support for app.nit centered around the class Service
module sessions

nitcorn :: sessions

Automated session management
module sexp

sexp :: sexp

S-Expression parsing facilities
module sha1

sha1 :: sha1

Provides methods to compute the SHA1 hash of a String
module shadow

gamnit :: shadow

Shadow mapping using a depth texture
module shared_preferences

android :: shared_preferences

Services allowing to save and load datas to internal android device
module shared_preferences_api10

android :: shared_preferences_api10

Services to save/load data using android.content.SharedPreferences for the android platform
module shared_preferences_api11

android :: shared_preferences_api11

Refines shared_preferences module to add API 11 services
module show_basedir

xdg_basedir :: show_basedir

Prints the local base directories as per the XDG Base Directory specification
module signal_handler

nitcorn :: signal_handler

Handle SIGINT and SIGTERM to close the server after all active events
module signals

signals :: signals

ANSI C signal handling
module simple

actors :: simple

A very simple example of the actor model
module simple_file_server

nitcorn :: simple_file_server

Basic file server on port 80 by default, may require root to execute
module simple_simulation

actors :: simple_simulation

Using agent_simulation by refining the Agent class to make
module socket

socket :: socket

Socket services
module socket_c

socket :: socket_c

Low-level socket functionalities
module socket_client

socket :: socket_client

Client sample using the Socket module which connect to the server sample.
module socket_server

socket :: socket_server

Server sample using the Socket module which allow client to connect
module socket_simple_server

socket :: socket_simple_server

Simple server example using a non-blocking TCPServer
module sqlite3

sqlite3 :: sqlite3

Services to manipulate a Sqlite3 database
module standard

standard :: standard

Old module implicitly imported by the old compiler.
module stanford

nlp :: stanford

Natural Language Processor based on the StanfordNLP core.
module static

json :: static

Static interface to read Nit objects from JSON strings
module stereoscopic_view

gamnit :: stereoscopic_view

Refine EulerCamera and App::frame_core_draw to get a stereoscopic view
module store

json :: store

Store and load json data.
module stream

core :: stream

Input and output streams of characters
module symbol

symbol :: symbol

Library for simple interning of strings
module syswm

sdl2 :: syswm

Window manager related SDL 2 services
module template

template :: template

Basic template system
module test_markdown

markdown2 :: test_markdown

Test suites for module markdown
module testing

saxophonit :: testing

Various utilities to help testing SAXophoNit (and SAX parsers in general).
module text_stat

text_stat :: text_stat

Injects stat-calculating functionalities to Text and its variants
module texture_atlas_parser

gamnit :: texture_atlas_parser

Tool to parse XML texture atlas and generated Nit code to access subtextures
module textures

gamnit :: textures

Load textures, create subtextures and manage their life-cycle
module thread_ring

actors :: thread_ring

Example implemented from "The computer Language Benchmarks Game" - Thread-Ring
module threaded_example

pthreads :: threaded_example

test for threaded annotation
module threadpool

pthreads :: threadpool

Introduces a minimal ThreadPool implementation using Tasks
module threadpool_example

pthreads :: threadpool_example

Simple example using threadpool
module tileset

gamnit :: tileset

Support for TileSet, TileSetFont and drawing text with TextSprites
module time

core :: time

Management of time and dates
module toast

android :: toast

Services to display a toast, a small popup on Android
module token

nitcorn :: token

Simple generate_token service, independent of the rest of the nitcorn framework
module trees

trees :: trees

General module for tree data structures
module trie

trees :: trie

A trie (or prefix tree) is a datastructure used to perform prefix searches.
module u16_string

core :: u16_string

Wrapper of ICU's UTF-16 encoded strings and conversion
module ui

android :: ui

Views and services to use the Android native user interface
module ui

app :: ui

Portable UI controls for mobiles apps
module ui

ios :: ui

Implementation of app::ui for iOS
module ui

linux :: ui

Implementation of the app.nit UI module for GNU/Linux
module ui_example

app :: ui_example

User interface example using app::ui
module ui_test

android :: ui_test

Test for app.nit's UI services
module uikit

ios :: uikit

File generated by objcwrapper
module undirected_clusters

dot :: undirected_clusters

Example from
module utf8

core :: utf8

Codec for UTF-8 I/O
module v3_10

gtk :: v3_10

GTK+ services added at version 3.10
module v3_4

gtk :: v3_4

module v3_6

gtk :: v3_6

GTK+ services added at version 3.6
module v3_8

gtk :: v3_8

GTK+ services added at version 3.8
module vararg_routes

nitcorn :: vararg_routes

Routes with parameters.
module vibration

android :: vibration

Vibration services for Android
module virtual_gamepad

gamnit :: virtual_gamepad

Virtual gamepad mapped to keyboard keys for quick and dirty mobile support
module vr

gamnit :: vr

VR support for gamnit depth, for Android only
module vsm

vsm :: vsm

Vector Space Model
module wallet

github :: wallet

Github OAuth tokens management
module websocket

websocket :: websocket

Adds support for a websocket connection in Nit
module websocket_server

websocket :: websocket_server

Sample module for a minimal chat server using Websockets on port 8088
module wifi

android :: wifi

Simple wrapper of the Android WiFi services
module write

msgpack :: write

Low-level write in MessagePack format to Writer streams
module x11

x11 :: x11

Services from the X11 library
module xdg_basedir

xdg_basedir :: xdg_basedir

Services for using the XDG Base Directory specification
module xml_entities

dom :: xml_entities

Basic blocks for DOM-XML representation
module xml_filter

sax :: xml_filter

Interface for an XML filter.
module xml_filter_impl

sax :: xml_filter_impl

Base class for deriving an XML filter.
module xml_reader

sax :: xml_reader

Interface for reading an XML document using callbacks.
module xor

crapto :: xor

Cryptographic attacks and utilities for XOR-based algorithms.
module xor_ciphers

crypto :: xor_ciphers

XOR oriented cryptographic ciphers and utilities.
# Services for byte streams and arrays
module bytes

import kernel
import collection::array
intrude import text::flat

# Any kind of entity which can be searched for in a Sequence of Byte
interface BytePattern
	# Return the first occurence of `self` in `b`, or -1 if not found
	fun first_index_in(b: SequenceRead[Int]): Int do return first_index_in_from(b, 0)

	# Return the first occurence of `self` in `b` starting at `from`, or -1 if not found
	fun first_index_in_from(b: SequenceRead[Int], from: Int): Int is abstract

	# Return the last occurence of `self` in `b`, or -1 if not found
	fun last_index_in(b: SequenceRead[Int]): Int do return last_index_in_from(b, b.length - 1)

	# Return the last occurence of `self` in `b`, or -1 if not found
	fun last_index_in_from(b: SequenceRead[Int], from: Int): Int is abstract

	# Returns the indexes of all the occurences of `self` in `b`
	fun search_all_in(b: SequenceRead[Int]): SequenceRead[Int] is abstract

	# Length of the pattern
	fun pattern_length: Int is abstract

	# Appends `self` to `b`
	fun append_to(b: Sequence[Int]) is abstract

	# Is `self` a prefix for `b` ?
	fun is_prefix(b: SequenceRead[Int]): Bool is abstract

	# Is `self` a suffix for `b` ?
	fun is_suffix(b: SequenceRead[Int]): Bool is abstract

redef class Int
	super BytePattern

	# Write self as a string into `ns` at position `pos`
	private fun add_digest_at(ns: CString, pos: Int) do
		var tmp = (0xF0 & self) >> 4
		ns[pos] = if tmp >= 0x0A then tmp + 0x37 else tmp + 0x30
		tmp = 0x0F & self
		ns[pos + 1] = if tmp >= 0x0A then tmp + 0x37 else tmp + 0x30

	# Is `self` a valid hexadecimal digit (in ASCII)
	# ~~~nit
	# intrude import core::bytes
	# assert not u'/'.is_valid_hexdigit
	# assert u'0'.is_valid_hexdigit
	# assert u'9'.is_valid_hexdigit
	# assert not u':'.is_valid_hexdigit
	# assert not u'@'.is_valid_hexdigit
	# assert u'A'.is_valid_hexdigit
	# assert u'F'.is_valid_hexdigit
	# assert not u'G'.is_valid_hexdigit
	# assert not u'`'.is_valid_hexdigit
	# assert u'a'.is_valid_hexdigit
	# assert u'f'.is_valid_hexdigit
	# assert not u'g'.is_valid_hexdigit
	# ~~~
	private fun is_valid_hexdigit: Bool do
		return (self >= 0x30 and self <= 0x39) or
		       (self >= 0x41 and self <= 0x46) or
		       (self >= 0x61 and self <= 0x66)

	# `self` as a hexdigit to its byte value
	# ~~~nit
	# intrude import core::bytes
	# assert 0x39.hexdigit_to_byteval == 0x09
	# assert 0x43.hexdigit_to_byteval == 0x0C
	# ~~~
	# REQUIRE: `self.is_valid_hexdigit`
	private fun hexdigit_to_byteval: Int do
		if self >= 0x30 and self <= 0x39 then
			return self - 0x30
		else if self >= 0x41 and self <= 0x46 then
			return self - 0x37
		else if self >= 0x61 and self <= 0x66 then
			return self - 0x57
		# Happens only if the requirement is not met.
		# i.e. this abort is here to please the compiler

	redef fun first_index_in_from(b, from) do
		for i in [from .. b.length[ do if b[i] == self then return i
		return -1

	redef fun last_index_in_from(b, from) do
		for i in [0 .. from].step(-1) do if b[i] == self then return i
		return -1

	redef fun search_all_in(b) do
		var ret = new Array[Int]
		var pos = 0
			pos = first_index_in_from(b, pos)
			if pos == -1 then return ret
			ret.add pos
			pos += 1

	redef fun pattern_length do return 1

	redef fun append_to(b) do b.push self

	#     assert u'b'.is_suffix("baqsdb".to_bytes)
	#     assert not u'b'.is_suffix("baqsd".to_bytes)
	redef fun is_suffix(b) do return b.length != 0 and b.last == self

	#     assert u'b'.is_prefix("baqsdb".to_bytes)
	#     assert not u'b'.is_prefix("aqsdb".to_bytes)
	redef fun is_prefix(b) do return b.length != 0 and b.first == self

	# A signed big-endian representation of `self`
	# ~~~
	# assert     1.to_bytes.hexdigest ==     "01"
	# assert   255.to_bytes.hexdigest ==     "FF"
	# assert   256.to_bytes.hexdigest ==   "0100"
	# assert 65535.to_bytes.hexdigest ==   "FFFF"
	# assert 65536.to_bytes.hexdigest == "010000"
	# ~~~
	# Negative values are converted to their two's complement.
	# Be careful as the result can be ambiguous.
	# ~~~
	# assert     (-1).to_bytes.hexdigest ==     "FF"
	# assert    (-32).to_bytes.hexdigest ==     "E0"
	# assert   (-512).to_bytes.hexdigest ==   "FE00"
	# assert (-65794).to_bytes.hexdigest == "FEFEFE"
	# ~~~
	# Optionally, set `n_bytes` to the desired number of bytes in the output.
	# This setting can disambiguate the result between positive and negative
	# integers. Be careful with this parameter as the result may overflow.
	# ~~~
	# assert        1.to_bytes(2).hexdigest ==     "0001"
	# assert    65535.to_bytes(2).hexdigest ==     "FFFF"
	# assert     (-1).to_bytes(2).hexdigest ==     "FFFF"
	# assert   (-512).to_bytes(4).hexdigest == "FFFFFE00"
	# assert 0x123456.to_bytes(2).hexdigest ==     "3456"
	# ~~~
	# For 0, a Bytes object with single nul byte is returned (instead of an empty Bytes object).
	# ~~~
	# assert 0.to_bytes.hexdigest == "00"
	# ~~~
	# For positive integers, `Bytes::to_i` can reverse the operation.
	# ~~~
	# assert 1234.to_bytes.to_i == 1234
	# ~~~
	# Require self >= 0
	fun to_bytes(n_bytes: nullable Int): Bytes do

		# If 0, force using at least one byte
		if self == 0 and n_bytes == null then n_bytes = 1

		# Compute the len (log256)
		var len = 1
		var max = 256
		var s = self.abs
		while s >= max do
			len += 1
			max *= 256

		# Two's complement
		s = self
		if self < 0 then
			var ff = 0
			for j in [0..len[ do
				ff *= 0x100
				ff += 0xFF

			s = ((-self) ^ ff) + 1

		# Cut long values
		if n_bytes != null and len > n_bytes then len = n_bytes

		# Allocate the buffer
		var cap = n_bytes or else len
		var res = new Bytes.with_capacity(cap)

		var filler = if self < 0 then 0xFF else 0
		for i in [0..cap[ do res[i] = filler

		# Fill it starting with the end
		var i = cap
		var sum = s
		while i > cap - len do
			i -= 1
			res[i] = sum % 256
			sum /= 256

		return res

# A buffer containing Byte-manipulation facilities
# Uses Copy-On-Write when persisted
class Bytes
	super AbstractArray[Int]
	super BytePattern

	# A CString being a char*, it can be used as underlying representation here.
	var items: CString

	# Number of bytes in the array
	redef var length

	# Capacity of the array
	private var capacity: Int

	# Has this buffer been persisted (to_s'd)?
	# Used for Copy-On-Write
	private var persisted = false

	#     var b = new Bytes.empty
	#     assert b.to_s == ""
	init empty do
		var ns = new CString(0)
		init(ns, 0, 0)

	# Init a `Bytes` with capacity `cap`
	init with_capacity(cap: Int) do
		var ns = new CString(cap)
		init(ns, 0, cap)

	redef fun pattern_length do return length

	redef fun is_empty do return length == 0

	#     var b = new Bytes.empty
	#     b.add 101
	#     assert b[0] == 101
	redef fun [](i) do
		assert i >= 0
		assert i < length
		return items[i]

	# Returns a copy of `self`
	fun clone: Bytes do
		var b = new Bytes.with_capacity(length)
		return b

	# Trims off the whitespaces at the beginning and the end of `self`
	#     var b = "102041426E6F1020" .hexdigest_to_bytes
	#     assert b.trim.hexdigest == "41426E6F"
	# NOTE: A whitespace is defined here as a byte whose value is <= 0x20
	fun trim: Bytes do
		var st = 0
		while st < length do
			if self[st] > 0x20 then break
			st += 1
		if st >= length then return new Bytes.empty
		var ed = length - 1
		while ed > 0 do
			if self[ed] > 0x20 then break
			ed -= 1
		return slice(st, ed - st + 1)

	# Copy a subset of `self` starting at `from` and of `count` bytes
	#     var b = "abcd".to_bytes
	#     assert b.slice(1, 2).hexdigest == "6263"
	#     assert b.slice(-1, 2).hexdigest == "61"
	#     assert b.slice(1, 0).hexdigest == ""
	#     assert b.slice(2, 5).hexdigest == "6364"
	fun slice(from, count: Int): Bytes do
		if count <= 0 then return new Bytes.empty

		if from < 0 then
			count += from
			if count < 0 then count = 0
			from = 0

		if (count + from) > length then count = length - from
		if count <= 0 then return new Bytes.empty

		var ret = new Bytes.with_capacity(count)

		ret.append_ns(items.fast_cstring(from), count)
		return ret

	# Copy of `self` starting at `from`
	#     var b = "abcd".to_bytes
	#     assert b.slice_from(1).hexdigest  == "626364"
	#     assert b.slice_from(-1).hexdigest == "61626364"
	#     assert b.slice_from(2).hexdigest  == "6364"
	fun slice_from(from: Int): Bytes do
		if from >= length then return new Bytes.empty
		if from < 0 then from = 0
		return slice(from, length)

	# Reverse the byte array in place
	#     var b = "abcd".to_bytes
	#     b.reverse
	#     assert b.to_s == "dcba"
	fun reverse
		var l = length
		for i in [0..l/2[ do
			var tmp = self[i]
			self[i] = self[l-i-1]
			self[l-i-1] = tmp

	# Returns self as an hexadecimal digest.
	# Also known as plain hexdump or postscript hexdump.
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.hexdigest == "61626364"
	# assert b.hexdigest.hexdigest_to_bytes == b
	# ~~~
	fun hexdigest: String do
		var elen = length * 2
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			self[i].add_digest_at(ns, oi)
			i += 1
			oi += 2
		return new FlatString.full(ns, elen, 0, elen)

	# Return self as a C hexadecimal digest where bytes are prefixed by `\x`
	# The output is compatible with literal stream of bytes for most languages
	# including C and Nit.
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.chexdigest == "\\x61\\x62\\x63\\x64"
	# assert b.chexdigest.unescape_to_bytes == b
	# ~~~
	fun chexdigest: String do
		var elen = length * 4
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			ns[oi] = u'\\'
			ns[oi+1] = u'x'
			self[i].add_digest_at(ns, oi+2)
			i += 1
			oi += 4
		return new FlatString.full(ns, elen, 0, elen)

	# Returns self as a stream of bits (0 and 1)
	# ~~~
	# var b = "abcd".to_bytes
	# assert b.binarydigest == "01100001011000100110001101100100"
	# assert b.binarydigest.binarydigest_to_bytes == b
	# ~~~
	fun binarydigest: String do
		var elen = length * 8
		var ns = new CString(elen)
		var i = 0
		var oi = 0
		while i < length do
			var c = self[i]
			var b = 128
			while b > 0 do
				if c & b == 0 then
					ns[oi] = u'0'
					ns[oi] = u'1'
				oi += 1
				b = b >> 1
			i += 1
		return new FlatString.full(ns, elen, 0, elen)

	# Interprets `self` as a big-endian integer (unsigned by default)
	# ~~~
	# var b = "0102".hexdigest_to_bytes
	# assert b.to_i == 258
	# assert   "01".hexdigest_to_bytes.to_i == 1
	# assert   "FF".hexdigest_to_bytes.to_i == 255
	# assert "0000".hexdigest_to_bytes.to_i == 0
	# ~~~
	# If `self.is_empty`, 0 is returned.
	# ~~~
	# assert "".hexdigest_to_bytes.to_i == 0
	# ~~~
	# If `signed == true`, the bytes are read as a signed integer.
	# As usual, the sign bit is the left most bit, no matter the
	# `length` of `self`.
	# ~~~
	# assert     "01".hexdigest_to_bytes.to_i(true) ==      1
	# assert     "FF".hexdigest_to_bytes.to_i(true) ==     -1
	# assert   "00FF".hexdigest_to_bytes.to_i(true) ==    255
	# assert     "E0".hexdigest_to_bytes.to_i(true) ==    -32
	# assert   "FE00".hexdigest_to_bytes.to_i(true) ==   -512
	# assert "FEFEFE".hexdigest_to_bytes.to_i(true) == -65794
	# ~~~
	# `Int::to_bytes` is a loosely reverse method.
	# ~~~
	# assert b.to_i.to_bytes == b
	# assert (b.to_i + 1).to_bytes.hexdigest == "0103"
	# assert "0001".hexdigest_to_bytes.to_i.to_bytes.hexdigest == "01"
	# assert (-32).to_bytes.to_i(true) == -32
	# ~~~
	# Warning: `Int` might overflow for bytes with more than 60 bits.
	fun to_i(signed: nullable Bool): Int do
		var res = 0
		var i = 0
		while i < length do
			res *= 256
			res += self[i].to_i
			i += 1

		# Two's complement is `signed`
		if signed == true and not_empty and first > 0x80 then
			var ff = 0
			for j in [0..length[ do
				ff *= 0x100
				ff += 0xFF

			res = -((res ^ ff) + 1)

		return res

	#     var b = new Bytes.with_capacity(1)
	#     b[0] = 101
	#     assert b.to_s == "e"
	redef fun []=(i, v) do
		if persisted then regen
		assert i >= 0
		assert i <= length
		if i == length then add(v)
		items[i] = v

	#     var b = new Bytes.empty
	#     b.add 101
	#     assert b.to_s == "e"
	redef fun add(c) do
		if persisted then regen
		if length >= capacity then
		items[length] = c
		length += 1

	# Adds the UTF-8 representation of `c` to `self`
	#     var b = new Bytes.empty
	#     b.add_char('A')
	#     b.add_char('キ')
	#     assert b.hexdigest == "41E382AD"
	fun add_char(c: Char) do
		if persisted then regen
		var cln = c.u8char_len
		var ln = length
		enlarge(ln + cln)
		items.set_char_at(length, c)
		length += cln

	redef fun has(c)
		if not c isa Int then return false
		return super(c&255)

	#     var b = new Bytes.empty
	#     b.append([104, 101, 108, 108, 111])
	#     assert b.to_s == "hello"
	redef fun append(arr) do
		if arr isa Bytes then
			append_ns(arr.items, arr.length)
			for i in arr do add i

	#     var b = new Bytes.empty
	#     b.append([0x41, 0x41, 0x18])
	#     b.pop
	#     assert b.to_s == "AA"
	redef fun pop do
		assert length >= 1
		length -= 1
		return items[length]

	redef fun clear do length = 0

	# Regenerates the buffer, necessary when it was persisted
	private fun regen do
		var nns = new CString(capacity)
		items.copy_to(nns, length, 0, 0)
		persisted = false

	# Appends the `ln` first bytes of `ns` to self
	fun append_ns(ns: CString, ln: Int) do
		if persisted then regen
		var nlen = length + ln
		if nlen > capacity then enlarge(nlen)
		ns.copy_to(items, ln, 0, length)
		length += ln

	# Appends `ln` bytes from `ns` starting at index `from` to self
	fun append_ns_from(ns: CString, ln, from: Int) do
		if persisted then regen
		var nlen = length + ln
		if nlen > capacity then enlarge(nlen)
		ns.copy_to(items, ln, from, length)
		length += ln

	# Appends the bytes of `str` to `self`
	fun append_text(str: Text) do str.append_to_bytes self

	redef fun append_to(b) do b.append self

	redef fun enlarge(sz) do
		if capacity >= sz then return
		persisted = false
		if capacity < 16 then capacity = 16
		while capacity < sz do capacity = capacity * 2 + 2
		var ns = new CString(capacity)
		items.copy_to(ns, length, 0, 0)
		items = ns

	redef fun to_s do
		persisted = true
		var b = self
		var r = b.items.to_s_unsafe(length, copy=false)
		if r != items then persisted = false
		return r

	redef fun iterator do return new BytesIterator.with_buffer(self)

	redef fun first_index_in_from(b, from) do
		if is_empty then return -1
		var fst = self[0]
		var bpos = fst.first_index_in_from(self, from)
		for i in [0 .. length[ do
			if self[i] != b[bpos] then return first_index_in_from(b, bpos + 1)
			bpos += 1
		return bpos

	redef fun last_index_in_from(b, from) do
		if is_empty then return -1
		var lst = self[length - 1]
		var bpos = lst.last_index_in_from(b, from)
		for i in [0 .. length[.step(-1) do
			if self[i] != b[bpos] then return last_index_in_from(b, bpos - 1)
			bpos -= 1
		return bpos

	redef fun search_all_in(b) do
		var ret = new Array[Int]
		var pos = first_index_in_from(b, 0)
		if pos == -1 then return ret
		pos = pos + 1
		ret.add pos
			pos = first_index_in_from(b, pos)
			if pos == -1 then return ret
			ret.add pos
			pos += length

	# Splits the content on self when encountering `b`
	#     var a = "String is string".to_bytes.split_with(u's')
	#     assert a.length == 3
	#     assert a[0].hexdigest == "537472696E672069"
	#     assert a[1].hexdigest == "20"
	#     assert a[2].hexdigest == "7472696E67"
	fun split_with(b: BytePattern): Array[Bytes] do
		var fst = b.search_all_in(self)
		if fst.is_empty then return [clone]
		var retarr = new Array[Bytes]
		var prev = 0
		for i in fst do
			retarr.add(slice(prev, i - prev))
			prev = i + b.pattern_length
		retarr.add slice_from(prev)
		return retarr

	# Splits `self` in two parts at the first occurence of `b`
	#     var a = "String is string".to_bytes.split_once_on(u's')
	#     assert a[0].hexdigest == "537472696E672069"
	#     assert a[1].hexdigest == "20737472696E67"
	fun split_once_on(b: BytePattern): Array[Bytes] do
		var spl = b.first_index_in(self)
		if spl == -1 then return [clone]
		var ret = new Array[Bytes].with_capacity(2)
		ret.add(slice(0, spl))
		ret.add(slice_from(spl + b.pattern_length))
		return ret

	# Replaces all the occurences of `this` in `self` by `by`
	#     var b = "String is string".to_bytes.replace(0x20, 0x41)
	#     assert b.hexdigest == "537472696E6741697341737472696E67"
	fun replace(pattern: BytePattern, bytes: BytePattern): Bytes do
		if is_empty then return new Bytes.empty
		var pos = pattern.search_all_in(self)
		if pos.is_empty then return clone
		var ret = new Bytes.with_capacity(length)
		var prev = 0
		for i in pos do
			ret.append_ns(items.fast_cstring(prev), i - prev)
			bytes.append_to ret
			prev = i + pattern.pattern_length
		ret.append(slice_from(pos.last + pattern.pattern_length))
		return ret

	# Decode `self` from percent (or URL) encoding to a clear string
	# Invalid '%' are not decoded.
	#     assert "aBc09-._~".to_bytes.from_percent_encoding == "aBc09-._~".to_bytes
	#     assert "%25%28%29%3c%20%3e".to_bytes.from_percent_encoding == "%()< >".to_bytes
	#     assert ".com%2fpost%3fe%3dasdf%26f%3d123".to_bytes.from_percent_encoding == ".com/post?e=asdf&f=123".to_bytes
	#     assert "%25%28%29%3C%20%3E".to_bytes.from_percent_encoding == "%()< >".to_bytes
	#     assert "incomplete %".to_bytes.from_percent_encoding == "incomplete %".to_bytes
	#     assert "invalid % usage".to_bytes.from_percent_encoding == "invalid % usage".to_bytes
	#     assert "%c3%a9%e3%81%82%e3%81%84%e3%81%86".to_bytes.from_percent_encoding == "éあいう".to_bytes
	#     assert "%1 %A %C3%A9A9".to_bytes.from_percent_encoding == "%1 %A éA9".to_bytes
	fun from_percent_encoding: Bytes do
		var tmp = new Bytes.with_capacity(length)
		var pos = 0
		while pos < length do
			var b = self[pos]
			if b != u'%' then
				tmp.add b
				pos += 1
			if length - pos < 2 then
				tmp.add u'%'
				pos += 1
			var bn = self[pos + 1]
			var bnn = self[pos + 2]
			if not bn.is_valid_hexdigit or not bnn.is_valid_hexdigit then
				tmp.add u'%'
				pos += 1
			tmp.add((bn.hexdigit_to_byteval << 4) + bnn.hexdigit_to_byteval)
			pos += 3
		return tmp

	# Is `b` a prefix of `self` ?
	fun has_prefix(b: BytePattern): Bool do return b.is_prefix(self)

	# Is `b` a suffix of `self` ?
	fun has_suffix(b: BytePattern): Bool do return b.is_suffix(self)

	redef fun is_suffix(b) do
		if length > b.length then return false
		var j = b.length - 1
		var i = length - 1
		while i > 0 do
			if self[i] != b[j] then return false
			i -= 1
			j -= 1
		return true

	redef fun is_prefix(b) do
		if length > b.length then return false
		for i in [0 .. length[ do if self[i] != b[i] then return false
		return true

private class BytesIterator
	super IndexedIterator[Int]

	var tgt: CString

	redef var index

	var max: Int

	init with_buffer(b: Bytes) do init(b.items, 0, b.length)

	redef fun is_ok do return index < max

	redef fun next do index += 1

	redef fun item do return tgt[index]

redef class Text
	# Returns a mutable copy of `self`'s bytes
	# ~~~nit
	# assert "String".to_bytes isa Bytes
	# assert "String".to_bytes == [83, 116, 114, 105, 110, 103]
	# ~~~
	fun to_bytes: Bytes do
		var b = new Bytes.with_capacity(byte_length)
		append_to_bytes b
		return b

	# Is `self` a valid hexdigest ?
	#     assert "0B1d3F".is_valid_hexdigest
	#     assert not "5G".is_valid_hexdigest
	fun is_valid_hexdigest: Bool do
		for i in bytes do if not i.is_valid_hexdigit then return false
		return true

	# Appends `self.bytes` to `b`
	fun append_to_bytes(b: Bytes) do
		for s in substrings do
			var from = if s isa FlatString then s.first_byte else 0
			b.append_ns_from(s.items, s.byte_length, from)

	# Returns a new `Bytes` instance with the digest as content
	#     assert "0B1F4D".hexdigest_to_bytes == [0x0B, 0x1F, 0x4D]
	#     assert "0B1F4D".hexdigest_to_bytes.hexdigest == "0B1F4D"
	# Characters that are not hexadecimal digits are ignored.
	#     assert "z0B1 F4\nD".hexdigest_to_bytes.hexdigest == "0B1F4D"
	#     assert "\\x0b1 \\xf4d".hexdigest_to_bytes.hexdigest == "0B1F4D"
	# When the number of hexadecimal digit is not even, then a leading 0 is
	# implicitly considered to fill the left byte (the most significant one).
	#     assert "1".hexdigest_to_bytes.hexdigest == "01"
	#     assert "FFF".hexdigest_to_bytes.hexdigest == "0FFF"
	# `Bytes::hexdigest` is a loosely reverse method since its
	# results contain only pairs of uppercase hexadecimal digits.
	#     assert "ABCD".hexdigest_to_bytes.hexdigest == "ABCD"
	#     assert "a b c".hexdigest_to_bytes.hexdigest == "0ABC"
	fun hexdigest_to_bytes: Bytes do
		var b = bytes
		var max = byte_length

		var dlength = 0 # Number of hex digits
		var pos = 0
		while pos < max do
			var c = b[pos]
			if c.is_valid_hexdigit then dlength += 1
			pos += 1

		# Allocate the result buffer
		var ret = new Bytes.with_capacity((dlength+1) / 2)

		var i = (dlength+1) % 2 # current hex digit (1=high, 0=low)
		var byte = 0 # current accumulated byte value

		pos = 0
		while pos < max do
			var c = b[pos]
			if c.is_valid_hexdigit then
				byte = byte << 4 | c.hexdigit_to_byteval
				i -= 1
				if i < 0 then
					# Last digit known: store and restart
					ret.add byte
					i = 1
					byte = 0
			pos += 1
		return ret

	# Gets the hexdigest of the bytes of `self`
	#     assert "&lt;STRING&#47;&rt;".hexdigest == "266C743B535452494E47262334373B2672743B"
	fun hexdigest: String do
		var ln = byte_length
		var outns = new CString(ln * 2)
		var oi = 0
		for i in [0 .. ln[ do
			bytes[i].add_digest_at(outns, oi)
			oi += 2
		return new FlatString.with_infos(outns, ln * 2, 0)

	# Return a `Bytes` instance where Nit escape sequences are transformed.
	#     assert "B\\n\\x41\\u0103D3".unescape_to_bytes.hexdigest == "420A41F0908F93"
	# `Bytes::chexdigest` is a loosely reverse methods since its result is only made
	# of `"\x??"` escape sequences.
	#     assert "\\x41\\x42\\x43".unescape_to_bytes.chexdigest == "\\x41\\x42\\x43"
	#     assert "B\\n\\x41\\u0103D3".unescape_to_bytes.chexdigest == "\\x42\\x0A\\x41\\xF0\\x90\\x8F\\x93"
	fun unescape_to_bytes: Bytes do
		var res = new Bytes.with_capacity(self.byte_length)
		var was_slash = false
		var i = 0
		while i < length do
			var c = self[i]
			if not was_slash then
				if c == '\\' then
					was_slash = true
				i += 1
			was_slash = false
			if c == 'n' then
			else if c == 'r' then
			else if c == 't' then
			else if c == '0' then
			else if c == 'x' or c == 'X' then
				var hx = substring(i + 1, 2)
				if hx.is_hex then
					res.add hx.to_hex
				i += 2
			else if c == 'u' or c == 'U' then
				var hx = substring(i + 1, 6)
				if hx.is_hex then
				i += 6
			i += 1
		return res

	# Return a `Bytes` by reading 0 and 1.
	#     assert "1010101100001101".binarydigest_to_bytes.hexdigest == "AB0D"
	# Note that characters that are neither 0 or 1 are just ignored.
	#     assert "a1B01 010\n1100あ001101".binarydigest_to_bytes.hexdigest == "AB0D"
	#     assert "hello".binarydigest_to_bytes.is_empty
	# When the number of bits is not divisible by 8, then leading 0 are
	# implicitly considered to fill the left byte (the most significant one).
	#     assert "1".binarydigest_to_bytes.hexdigest == "01"
	#     assert "1111111".binarydigest_to_bytes.hexdigest == "7F"
	#     assert "1000110100".binarydigest_to_bytes.hexdigest == "0234"
	# `Bytes::binarydigest` is a loosely reverse method since its
	# results contain only 1 and 0 by blocks of 8.
	#     assert "1010101100001101".binarydigest_to_bytes.binarydigest == "1010101100001101"
	#     assert "1".binarydigest_to_bytes.binarydigest == "00000001"
	fun binarydigest_to_bytes: Bytes
		var b = bytes
		var max = byte_length

		# Count bits
		var bitlen = 0
		var pos = 0
		while pos < max do
			var c = b[pos]
			pos += 1
			if c == u'0' or c == u'1' then bitlen += 1

		# Allocate (and take care of the padding)
		var ret = new Bytes.with_capacity((bitlen+7) / 8)

		var i = (bitlen+7) % 8 # current bit (7th=128, 0th=1)
		var byte = 0 # current accumulated byte value

		pos = 0
		while pos < max do
			var c = b[pos]
			pos += 1
			if c == u'0' then
				byte = byte << 1
			else if c == u'1' then
				byte = byte << 1 | 1

			i -= 1
			if i < 0 then
				# Last bit known: store and restart
				ret.add byte
				i = 7
				byte = 0
		return ret

redef class FlatText
	redef fun append_to_bytes(b) do
		var from = if self isa FlatString then first_byte else 0
		if isset _items then b.append_ns_from(items, byte_length, from)

redef class CString
	# Creates a new `Bytes` object from `self` with `len` as length
	# If `len` is null, strlen will determine the length of the Bytes
	fun to_bytes(len: nullable Int): Bytes do
		if len == null then len = cstring_length
		return new Bytes(self, len, len)

	# Creates a new `Bytes` object from a copy of `self` with `len` as length
	# If `len` is null, strlen will determine the length of the Bytes
	fun to_bytes_with_copy(len: nullable Int): Bytes do
		if len == null then len = cstring_length
		var nns = new CString(len)
		copy_to(nns, len, 0, 0)
		return new Bytes(nns, len, len)

# Joins an array of bytes `arr` separated by `sep`
#     assert join_bytes(["String".to_bytes, "is".to_bytes, "string".to_bytes], u' ').hexdigest == "537472696E6720697320737472696E67"
fun join_bytes(arr: Array[Bytes], sep: nullable BytePattern): Bytes do
	if arr.is_empty then return new Bytes.empty
	sep = sep or else new Bytes.empty
	var endln = sep.pattern_length * (arr.length - 1)
	for i in arr do endln += i.length
	var ret = new Bytes.with_capacity(endln)
	for i in  [1 .. arr.length[ do
		ret.append arr[i]
	return ret