All the array-based text representations

Introduced classes

class FlatBuffer

core :: FlatBuffer

Mutable strings of characters.
abstract class FlatString

core :: FlatString

Immutable strings of characters.

Redefined classes

redef class Array[E: nullable Object]

core :: flat $ Array

Resizable one dimension array of objects.
redef abstract class Buffer

core :: flat $ Buffer

A mutable sequence of characters.
redef extern class CString

core :: flat $ CString

C string char *
redef abstract class FlatText

core :: flat $ FlatText

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

core :: flat $ Int

Native integer numbers.
redef interface Map[K: nullable Object, V: nullable Object]

core :: flat $ Map

Maps are associative collections: key -> item.
redef enum NativeArray[E: nullable Object]

core :: flat $ NativeArray

Native Nit array

All class definitions

redef class Array[E: nullable Object]

core :: flat $ Array

Resizable one dimension array of objects.
redef abstract class Buffer

core :: flat $ Buffer

A mutable sequence of characters.
redef extern class CString

core :: flat $ CString

C string char *
class FlatBuffer

core $ FlatBuffer

Mutable strings of characters.
abstract class FlatString

core $ FlatString

Immutable strings of characters.
redef abstract class FlatText

core :: flat $ FlatText

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

core :: flat $ Int

Native integer numbers.
redef interface Map[K: nullable Object, V: nullable Object]

core :: flat $ Map

Maps are associative collections: key -> item.
redef enum NativeArray[E: nullable Object]

core :: flat $ NativeArray

Native Nit array
package_diagram core::flat flat core::abstract_text abstract_text core::flat->core::abstract_text core::native native core::abstract_text->core::native ...core::native ... ...core::native->core::native core::ropes ropes core::ropes->core::flat core::bytes bytes core::bytes->core::flat core::text text core::text->core::ropes core::text... ... core::text...->core::text core::codec_base codec_base core::codec_base->core::bytes core::codec_base... ... core::codec_base...->core::codec_base

Ancestors

module abstract_collection

core :: abstract_collection

Abstract collection classes and services.
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

Parents

module abstract_text

core :: abstract_text

Abstract class for manipulation of sequences of characters

Children

module bytes

core :: bytes

Services for byte streams and arrays
module ropes

core :: ropes

Tree-based representation of a String.

Descendants

module a_star

a_star :: a_star

A* pathfinding in graphs
module a_star-m

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

app :: app

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

ios :: app

Basic structure for Nit apps on iOS
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

app :: assets

Portable services to load resources from the assets folder
module assets

ios :: assets

Implementation of app::assets
module assets

android :: 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

linux :: audio

app::audio implementation for GNU/Linux using SDL2 mixer
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 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 http://www.graphviz.org/content/cluster
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 codec_base

core :: codec_base

Base for codecs to use with streams
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

ios :: data_store

Implements app::data_store using NSUserDefaults
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

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

core :: error

Standard error-management infrastructure.
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

sdl2 :: events

SDL 2 events and related services
module events

github :: events

Events are emitted by Github Hooks.
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

curl :: extra

Shortcut services for scripts: http_get and http_download
module extra

pthreads :: extra

Offers some POSIX threads services that are not available on all platforms
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 http://www.graphviz.org/content/hello
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

linux :: http_request

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

app :: http_request

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

android :: http_request

Android implementation of app:http_request
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_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

bcm2835 :: input

module input

mnit :: input

Defines abstract classes for user and general inputs to the application.
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 java.io 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

android :: landscape

Lock the application in the landscape orientation
module landscape

gamnit :: 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

nitcorn :: log

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

android :: log

Advanced Android logging services
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

markdown :: nitmd

A Markdown parser for Nit.
module nitmd

markdown2 :: 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 numeric

core :: numeric

Advanced services for Numeric types
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

android :: platform

Triggers compilation for the android platform
module platform

ios :: platform

Triggers compilation for the iOS 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

pthreads :: pthreads

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

nitcorn :: pthreads

Activate the use of pthreads with nitcorn
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 re

core :: re

Regular expression support for all services based on Pattern
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

core :: text

All the classes and methods related to the manipulation of text entities
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

ios :: ui

Implementation of app::ui for iOS
module ui

linux :: ui

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

app :: ui

Portable UI controls for mobiles apps
module ui

android :: ui

Views and services to use the Android native user interface
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 http://www.graphviz.org/Gallery/undirected/fdpclust.html
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.
# All the array-based text representations
module flat

intrude import abstract_text
intrude import native

`{
#include <stdio.h>
#include <string.h>
`}

private class FlatSubstringsIter
	super Iterator[FlatText]

	var tgt: nullable FlatText

	redef fun item do
		assert is_ok
		return tgt.as(not null)
	end

	redef fun is_ok do return tgt != null

	redef fun next do tgt = null
end

redef class FlatText

	# First byte of the CString
	protected fun first_byte: Int do return 0

	# Last byte of the CString
	protected fun last_byte: Int do return first_byte + _byte_length - 1

	# Cache of the latest position (char) explored in the string
	var position: Int = 0

	# Cached position (bytes) in the CString underlying the String
	var bytepos: Int = 0

	# Index of the character `index` in `_items`
	fun char_to_byte_index(index: Int): Int do
		var dpos = index - _position
		var b = _bytepos
		var its = _items

		if dpos == 1 then
			if its[b] & 0x80 == 0x00 then
				b += 1
			else
				b += its.length_of_char_at(b)
			end
			_bytepos = b
			_position = index
			return b
		end
		if dpos == -1 then
			b = its.find_beginning_of_char_at(b - 1)
			_bytepos = b
			_position = index
			return b
		end
		if dpos == 0 then return b

		var ln = _length
		var pos = _position
		# Find best insertion point
		var delta_begin = index
		var delta_end = (ln - 1) - index
		var delta_cache = (pos - index).abs
		var min = delta_begin

		if delta_cache < min then min = delta_cache
		if delta_end < min then min = delta_end

		var ns_i: Int
		var my_i: Int

		if min == delta_cache then
			ns_i = _bytepos
			my_i = pos
		else if min == delta_begin then
			ns_i = first_byte
			my_i = 0
		else
			ns_i = its.find_beginning_of_char_at(last_byte)
			my_i = _length - 1
		end

		ns_i = its.char_to_byte_index_cached(index, my_i, ns_i)

		_position = index
		_bytepos = ns_i

		return ns_i
	end

	# By escaping `self` to HTML, how many more bytes will be needed ?
	fun chars_to_html_escape: Int do
		var its = _items
		var max = last_byte
		var pos = first_byte
		var endlen = 0
		while pos <= max do
			var c = its[pos]
			if c == u'<' then
				endlen += 3
			else if c == u'>' then
				endlen += 3
			else if c == u'&' then
				endlen += 4
			else if c == u'"' then
				endlen += 4
			else if c == u'\'' then
				endlen += 4
			else if c == 0x2F then
				endlen += 4
			end
			pos += 1
		end
		return endlen
	end

	redef fun html_escape
	do
		var extra = chars_to_html_escape
		if extra == 0 then return to_s
		var its = _items
		var max = last_byte
		var pos = first_byte
		var nlen = extra + _byte_length
		var nits = new CString(nlen)
		var outpos = 0
		while pos <= max do
			var c = its[pos]
			# Special codes:
			# Some HTML characters are used as meta-data, they need
			# to be replaced by an HTML-Escaped equivalent
			if c == u'<' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'l'
				nits[outpos + 2] = u't'
				nits[outpos + 3] = u';'
				outpos += 4
			else if c == u'>' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'g'
				nits[outpos + 2] = u't'
				nits[outpos + 3] = u';'
				outpos += 4
			else if c == u'&' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'a'
				nits[outpos + 2] = u'm'
				nits[outpos + 3] = u'p'
				nits[outpos + 4] = u';'
				outpos += 5
			else if c == u'"' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'#'
				nits[outpos + 2] = u'3'
				nits[outpos + 3] = u'4'
				nits[outpos + 4] = u';'
				outpos += 5
			else if c == u'\'' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'#'
				nits[outpos + 2] = u'3'
				nits[outpos + 3] = u'9'
				nits[outpos + 4] = u';'
				outpos += 5
			else if c == u'/' then
				nits[outpos] = u'&'
				nits[outpos + 1] = u'#'
				nits[outpos + 2] = u'4'
				nits[outpos + 3] = u'7'
				nits[outpos + 4] = u';'
				outpos += 5
			else
				nits[outpos] = c
				outpos += 1
			end
			pos += 1
		end
		var s = new FlatString.with_infos(nits, nlen, 0)
		return s
	end

	# By escaping `self` to C, how many more bytes will be needed ?
	#
	# This enables a double-optimization in `escape_to_c` since if this
	# method returns 0, then `self` does not need escaping and can be
	# returned as-is
	fun chars_to_escape_to_c: Int do
		var its = _items
		var max = last_byte
		var pos = first_byte
		var req_esc = 0
		while pos <= max do
			var c = its[pos]
			if c == u'\n' then
				req_esc += 1
			else if c == u'\t' then
				req_esc += 1
			else if c == u'"' then
				req_esc += 1
			else if c == u'\'' then
				req_esc += 1
			else if c == u'\\' then
				req_esc += 1
			else if c == u'?' then
				var j = pos + 1
				if j < length then
					var next = its[j]
					# We ignore `??'` because it will be escaped as `??\'`.
					if
						next == 0x21 or
						next == 0x28 or
						next == 0x29 or
						next == 0x2D or
						next == 0x2F or
						next == 0x3C or
						next == 0x3D or
						next == 0x3E
					then req_esc += 1
				end
			else if c < 32 then
				req_esc += 3
			end
			pos += 1
		end
		return req_esc
	end

	redef fun escape_to_c do
		var ln_extra = chars_to_escape_to_c
		if ln_extra == 0 then return self.to_s
		var its = _items
		var max = last_byte
		var nlen = _byte_length + ln_extra
		var nns = new CString(nlen)
		var pos = first_byte
		var opos = 0
		while pos <= max do
			var c = its[pos]
			# Special codes:
			#
			# Any byte with value < 32 is a control character
			# All their uses will be replaced by their octal
			# value in C.
			#
			# There are two exceptions however:
			#
			# * 0x09 => \t
			# * 0x0A => \n
			#
			# Aside from the code points above, the following are:
			#
			# * 0x22 => \"
			# * 0x27 => \'
			# * 0x5C => \\
			if c == u'\t' then
				nns[opos] = u'\\'
				nns[opos + 1] = u't'
				opos += 2
			else if c == u'\n' then
				nns[opos] = u'\\'
				nns[opos + 1] = u'n'
				opos += 2
			else if c == u'"' then
				nns[opos] = u'\\'
				nns[opos + 1] = u'"'
				opos += 2
			else if c == u'\'' then
				nns[opos] = u'\\'
				nns[opos + 1] = u'\''
				opos += 2
			else if c == u'\\' then
				nns[opos] = u'\\'
				nns[opos + 1] = u'\\'
				opos += 2
			else if c == u'?' then
				var j = pos + 1
				if j < length then
					var next = its[j]
					# We ignore `??'` because it will be escaped as `??\'`.
					if
						next == 0x21 or
						next == 0x28 or
						next == 0x29 or
						next == 0x2D or
						next == 0x2F or
						next == 0x3C or
						next == 0x3D or
						next == 0x3E
					then
						nns[opos] = 0x5C
						opos += 1
					end
				end
				nns[opos] = 0x3F
				opos += 1
			else if c < 32 then
				nns[opos] = u'\\'
				nns[opos + 1] = u'0'
				nns[opos + 2] = ((c & 0x38) >> 3) + u'0'
				nns[opos + 3] = (c & 0x07) + u'0'
				opos += 4
			else
				nns[opos] = c
				opos += 1
			end
			pos += 1
		end
		return nns.to_s_unsafe(nlen, copy=false, clean=false)
	end

	redef fun [](index) do
		var len = _length

		# Statistically:
		# * ~70% want the next char
		# * ~23% want the previous
		# * ~7% want the same char
		#
		# So it makes sense to shortcut early. And early is here.
		var dpos = index - _position
		var b = _bytepos
		if dpos == 1 and index < len - 1 then
			var its = _items
			var c = its[b]
			if c & 0x80 == 0x00 then
				# We want the next, and current is easy.
				# So next is easy to find!
				b += 1
				_position = index
				_bytepos = b
				# The rest will be done by `dpos==0` bellow.
				dpos = 0
			end
		else if dpos == -1 and index > 1 then
			var its = _items
			var c = its[b-1]
			if c & 0x80 == 0x00 then
				# We want the previous, and it is easy.
				b -= 1
				dpos = 0
				_position = index
				_bytepos = b
				return c.code_point
			end
		end
		if dpos == 0 then
			# We know what we want (+0 or +1) just get it now!
			var its = _items
			var c = its[b]
			if c & 0x80 == 0x00 then return c.code_point
			return items.char_at(b)
		end

		assert index >= 0 and index < len
		return fetch_char_at(index)
	end

	# Gets a `Char` at `index` in `self`
	#
	# WARNING: Use at your own risks as no bound-checking is done
	fun fetch_char_at(index: Int): Char do
		var i = char_to_byte_index(index)
		var items = _items
		var b = items[i]
		if b & 0x80 == 0x00 then return b.code_point
		return items.char_at(i)
	end

	# If `self` contains only digits and alpha <= 'f', return the corresponding integer.
	#
	#     assert "ff".to_hex == 255
	redef fun to_hex(pos, ln) do
		var res = 0
		if pos == null then pos = 0
		if ln == null then ln = length - pos
		pos = char_to_byte_index(pos)
		var its = _items
		var max = pos + ln
		for i in [pos .. max[ do
			res <<= 4
			res += its[i].code_point.from_hex
		end
		return res
	end

	redef fun copy_to_native(dst, n, src_off, dst_off) do
		_items.copy_to(dst, n, first_byte + src_off, dst_off)
	end
end

# Immutable strings of characters.
abstract class FlatString
	super FlatText
	super String

	# Index at which `self` begins in `_items`, inclusively
	redef var first_byte is noinit

	redef fun chars do return new FlatStringCharView(self)

	redef fun bytes do return new FlatStringByteView(self)

	redef fun to_cstring do
		var blen = _byte_length
		var new_items = new CString(blen + 1)
		_items.copy_to(new_items, blen, _first_byte, 0)
		new_items[blen] = 0
		return new_items
	end

	redef fun reversed do
		var b = new FlatBuffer.with_capacity(_byte_length + 1)
		var i = _length - 1
		while i >= 0 do
			b.add self.fetch_char_at(i)
			i -= 1
		end
		var s = b.to_s.as(FlatString)
		s._length = self._length
		return s
	end

	redef fun fast_cstring do return _items.fast_cstring(_first_byte)

	redef fun substring(from, count)
	do
		if count <= 0 then return ""

		if from < 0 then
			count += from
			if count <= 0 then return ""
			from = 0
		end

		var ln = _length
		if (count + from) > ln then count = ln - from
		if count <= 0 then return ""
		var end_index = from + count - 1
		return substring_impl(from, count, end_index)
	end

	private fun substring_impl(from, count, end_index: Int): String do
		var cache = _position
		var dfrom = (cache - from).abs
		var dend = (end_index - from).abs

		var bytefrom: Int
		var byteto: Int
		if dfrom < dend then
			bytefrom = char_to_byte_index(from)
			byteto = char_to_byte_index(end_index)
		else
			byteto = char_to_byte_index(end_index)
			bytefrom = char_to_byte_index(from)
		end

		var its = _items
		byteto += its.length_of_char_at(byteto) - 1

		var s = new FlatString.full(its, byteto - bytefrom + 1, bytefrom, count)
		return s
	end

	redef fun empty do return "".as(FlatString)

	redef fun to_upper
	do
		var outstr = new FlatBuffer.with_capacity(self._byte_length + 1)

		var mylen = _length
		var pos = 0

		while pos < mylen do
			outstr.add(chars[pos].to_upper)
			pos += 1
		end

		return outstr.to_s
	end

	redef fun to_lower
	do
		var outstr = new FlatBuffer.with_capacity(self._byte_length + 1)

		var mylen = _length
		var pos = 0

		while pos < mylen do
			outstr.add(chars[pos].to_lower)
			pos += 1
		end

		return outstr.to_s
	end

	redef fun output
	do
		for i in chars do i.output
	end

	##################################################
	#              String Specific Methods           #
	##################################################

	# Low-level creation of a new string with minimal data.
	#
	# `_items` will be used as is, without copy, to retrieve the characters of the string.
	# Aliasing issues is the responsibility of the caller.
	private new with_infos(items: CString, byte_length, from: Int)
	do
		var len = items.utf8_length(from, byte_length)
		if byte_length == len then return new ASCIIFlatString.full_data(items, byte_length, from, len)
		return new UnicodeFlatString.full_data(items, byte_length, from, len)
	end

	# Low-level creation of a new string with all the data.
	#
	# `_items` will be used as is, without copy, to retrieve the characters of the string.
	# Aliasing issues is the responsibility of the caller.
	private new full(items: CString, byte_length, from, length: Int)
	do
		if byte_length == length then return new ASCIIFlatString.full_data(items, byte_length, from, length)
		return new UnicodeFlatString.full_data(items, byte_length, from, length)
	end

	redef fun ==(other)
	do
		if not other isa FlatText then return super

		if self.object_id == other.object_id then return true

		var my_length = _byte_length

		if other._byte_length != my_length then return false

		var my_index = _first_byte
		var its_index = other.first_byte

		var last_iteration = my_index + my_length

		var its_items = other._items
		var my_items = self._items

		while my_index < last_iteration do
			if my_items[my_index] != its_items[its_index] then return false
			my_index += 1
			its_index += 1
		end

		return true
	end

	redef fun <(other)
	do
		if not other isa FlatText then return super

		if self.object_id == other.object_id then return false

		var myits = _items
		var itsits = other._items

		var mbt = _byte_length
		var obt = other.byte_length

		var minln = if mbt < obt then mbt else obt
		var mst = _first_byte
		var ost = other.first_byte

		for i in [0 .. minln[ do
			var my_curr_char = myits[mst]
			var its_curr_char = itsits[ost]

			if my_curr_char > its_curr_char then return false
			if my_curr_char < its_curr_char then return true

			mst += 1
			ost += 1
		end

		return mbt < obt
	end

	redef fun +(o) do
		var s = o.to_s
		var slen = s.byte_length
		var mlen = _byte_length
		var nlen = mlen + slen
		var mits = _items
		var mifrom = _first_byte
		if s isa FlatText then
			var sits = s._items
			var sifrom = s.first_byte
			var ns = new CString(nlen + 1)
			mits.copy_to(ns, mlen, mifrom, 0)
			sits.copy_to(ns, slen, sifrom, mlen)
			return new FlatString.full(ns, nlen, 0, _length + o.length)
		else
			abort
		end
	end

	redef fun *(i) do
		var mybtlen = _byte_length
		var new_byte_length = mybtlen * i
		var mylen = _length
		var newlen = mylen * i
		var its = _items
		var fb = _first_byte
		var ns = new CString(new_byte_length + 1)
		ns[new_byte_length] = 0
		var offset = 0
		while i > 0 do
			its.copy_to(ns, mybtlen, fb, offset)
			offset += mybtlen
			i -= 1
		end
		return new FlatString.full(ns, new_byte_length, 0, newlen)
	end

	redef fun hash
	do
		if hash_cache == null then
			# djb2 hash algorithm
			var h = 5381
			var i = _first_byte

			var my_items = _items
			var max = last_byte

			while i <= max do
				h = (h << 5) + h + my_items[i].to_i
				i += 1
			end

			hash_cache = h
		end

		return hash_cache.as(not null)
	end

	redef fun substrings do return new FlatSubstringsIter(self)
end

# Regular Nit UTF-8 strings
private class UnicodeFlatString
	super FlatString

	init full_data(items: CString, byte_length, from, length: Int) do
		self._items = items
		self._length = length
		self._byte_length = byte_length
		_first_byte = from
		_bytepos = from
	end

	redef fun substring_from(from) do
		if from >= self._length then return empty
		if from <= 0 then return self
		var c = char_to_byte_index(from)
		var st = c - _first_byte
		var fln = byte_length - st
		return new FlatString.full(items, fln, c, _length - from)
	end
end

# Special cases of String where all the characters are ASCII-based
#
# Optimizes access operations to O(1) complexity.
private class ASCIIFlatString
	super FlatString

	init full_data(items: CString, byte_length, from, length: Int) do
		self._items = items
		self._length = length
		self._byte_length = byte_length
		_first_byte = from
		_bytepos = from
	end

	redef fun [](idx) do
		assert idx < _byte_length and idx >= 0
		return _items[idx + _first_byte].code_point
	end

	redef fun substring(from, count) do
		var ln = _length
		if count <= 0 then return ""
		if (count + from) > ln then count = ln - from
		if count <= 0 then return ""
		if from < 0 then
			count += from
			if count <= 0 then return ""
			from = 0
		end
		return new ASCIIFlatString.full_data(_items, count, from + _first_byte, count)
	end

	redef fun reversed do
		var b = new FlatBuffer.with_capacity(_byte_length + 1)
		var i = _length - 1
		while i >= 0 do
			b.add self[i]
			i -= 1
		end
		var s = b.to_s.as(FlatString)
		return s
	end

	redef fun char_to_byte_index(index) do return index + _first_byte

	redef fun substring_impl(from, count, end_index) do
		return new ASCIIFlatString.full_data(_items, count, from + _first_byte, count)
	end

	redef fun fetch_char_at(i) do return _items[i + _first_byte].code_point
end

private class FlatStringCharReverseIterator
	super IndexedIterator[Char]

	var target: FlatString

	var curr_pos: Int

	redef fun is_ok do return curr_pos >= 0

	redef fun item do return target[curr_pos]

	redef fun next do curr_pos -= 1

	redef fun index do return curr_pos

end

private class FlatStringCharIterator
	super IndexedIterator[Char]

	var target: FlatString

	var max: Int is noautoinit

	var curr_pos: Int

	init do max = target._length - 1

	redef fun is_ok do return curr_pos <= max

	redef fun item do return target[curr_pos]

	redef fun next do curr_pos += 1

	redef fun index do return curr_pos

end

private class FlatStringCharView
	super StringCharView

	redef type SELFTYPE: FlatString

	redef fun [](index) do return target[index]

	redef fun iterator_from(start) do return new FlatStringCharIterator(target, start)

	redef fun reverse_iterator_from(start) do return new FlatStringCharReverseIterator(target, start)

end

private class FlatStringByteReverseIterator
	super IndexedIterator[Int]

	var target: FlatString

	var target_items: CString is noautoinit

	var curr_pos: Int

	init
	do
		var tgt = target
		target_items = tgt._items
		curr_pos += tgt._first_byte
	end

	redef fun is_ok do return curr_pos >= target._first_byte

	redef fun item do return target_items[curr_pos]

	redef fun next do curr_pos -= 1

	redef fun index do return curr_pos - target._first_byte

end

private class FlatStringByteIterator
	super IndexedIterator[Int]

	var target: FlatString

	var target_items: CString is noautoinit

	var curr_pos: Int

	init
	do
		var tgt = target
		target_items = tgt._items
		curr_pos += tgt._first_byte
	end

	redef fun is_ok do return curr_pos <= target.last_byte

	redef fun item do return target_items[curr_pos]

	redef fun next do curr_pos += 1

	redef fun index do return curr_pos - target._first_byte

end

private class FlatStringByteView
	super StringByteView

	redef type SELFTYPE: FlatString

	redef fun [](index)
	do
		# Check that the index (+ _first_byte) is not larger than last_byte
		# In other terms, if the index is valid
		var target = _target
		assert index >= 0 and index < target._byte_length
		var ind = index + target._first_byte
		return target._items[ind]
	end

	redef fun iterator_from(start) do return new FlatStringByteIterator(target, start)

	redef fun reverse_iterator_from(start) do return new FlatStringByteReverseIterator(target, start)

end

redef class Buffer
	redef new do return new FlatBuffer

	redef new with_cap(i) do return new FlatBuffer.with_capacity(i)
end

# Mutable strings of characters.
class FlatBuffer
	super FlatText
	super Buffer

	redef fun chars do return new FlatBufferCharView(self)

	redef fun bytes do return new FlatBufferByteView(self)

	private var capacity = 0

	redef fun fast_cstring do return _items.fast_cstring(0)

	redef fun substrings do return new FlatSubstringsIter(self)

	# Re-copies the `CString` into a new one and sets it as the new `Buffer`
	#
	# This happens when an operation modifies the current `Buffer` and
	# the Copy-On-Write flag `written` is set at true.
	private fun reset do
		var nns = new CString(capacity)
		if _byte_length != 0 then _items.copy_to(nns, _byte_length, 0, 0)
		_items = nns
		written = false
	end

	# Shifts the content of the buffer by `len` bytes to the right, starting at byte `from`
	#
	# Internal only, does not modify _byte_length or length, this is the caller's responsability
	private fun rshift_bytes(from: Int, len: Int) do
		var oit = _items
		var nit = _items
		var bt = _byte_length
		if bt + len > capacity then
			capacity = capacity * 2 + 2
			nit = new CString(capacity)
			oit.copy_to(nit, 0, 0, from)
		end
		oit.copy_to(nit, bt - from, from, from + len)
	end

	# Shifts the content of the buffer by `len` bytes to the left, starting at `from`
	#
	# Internal only, does not modify _byte_length or length, this is the caller's responsability
	private fun lshift_bytes(from: Int, len: Int) do
		var it = _items
		it.copy_to(it, _byte_length - from, from, from - len)
	end

	redef fun []=(index, item)
	do
		assert index >= 0 and index <= _length
		if written then reset
		if index == _length then
			add item
			return
		end
		var it = _items
		var ip = it.char_to_byte_index(index)
		var c = it.char_at(ip)
		var clen = c.u8char_len
		var itemlen = item.u8char_len
		var size_diff = itemlen - clen
		if size_diff > 0 then
			rshift_bytes(ip + clen, size_diff)
		else if size_diff < 0 then
			lshift_bytes(ip + clen, -size_diff)
		end
		_byte_length += size_diff
		it.set_char_at(ip, item)
	end

	redef fun insert(s, pos) do
		assert pos >= 0 and pos <= length
		if pos == length then
			append s
			return
		end
		var slen = s.byte_length
		enlarge(byte_length + slen)
		var it = _items
		var shpos = it.char_to_byte_index(pos)
		rshift_bytes(shpos, slen)
		s.copy_to_native(it, slen, 0, shpos)
		length += s.length
		byte_length += slen
	end

	redef fun insert_char(c, pos) do
		assert pos >= 0 and pos <= length
		if pos == length then
			add c
			return
		end
		var clen = c.u8char_len
		enlarge(byte_length + clen)
		var it = _items
		var shpos = it.char_to_byte_index(pos)
		rshift_bytes(shpos, clen)
		it.set_char_at(shpos, c)
		length += 1
		byte_length += clen
	end

	redef fun add(c)
	do
		if written then reset
		var clen = c.u8char_len
		var bt = _byte_length
		enlarge(bt + clen)
		_items.set_char_at(bt, c)
		_byte_length += clen
		_length += 1
	end

	redef fun clear do
		_byte_length = 0
		_length = 0
		if written then
			_capacity = 16
			reset
		end
	end

	redef fun empty do return new Buffer

	redef fun enlarge(cap)
	do
		var c = capacity
		if cap <= c then return
		if c <= 16 then c = 16
		while c <= cap do c = c * 2
		# The COW flag can be set at false here, since
		# it does a copy of the current `Buffer`
		written = false
		var bln = _byte_length
		var a = new CString(c)
		if bln > 0 then
			var it = _items
			if bln > 0 then it.copy_to(a, bln, 0, 0)
		end
		_items = a
		capacity = c
	end

	redef fun to_s
	do
		written = true
		var bln = _byte_length
		if bln == 0 then _items = new CString(1)
		return new FlatString.full(_items, bln, 0, _length)
	end

	redef fun to_cstring
	do
		var bln = _byte_length
		var new_native = new CString(bln + 1)
		new_native[bln] = 0
		if _length > 0 then _items.copy_to(new_native, bln, 0, 0)
		return new_native
	end

	# Create a new empty string.
	init do end

	# Low-level creation a new buffer with given data.
	#
	# `_items` will be used as is, without copy, to store the characters of the buffer.
	# Aliasing issues is the responsibility of the caller.
	#
	# If `_items` is shared, `written` should be set to true after the creation
	# so that a modification will do a copy-on-write.
	private init with_infos(items: CString, capacity, byte_length, length: Int)
	do
		self._items = items
		self.capacity = capacity
		self._byte_length = byte_length
		self._length = length
	end

	# Create a new string copied from `s`.
	init from(s: Text)
	do
		_items = new CString(s.byte_length)
		for i in s.substrings do i._items.copy_to(_items, i._byte_length, first_byte, 0)
		_byte_length = s.byte_length
		_length = s.length
		_capacity = _byte_length
	end

	# Create a new empty string with a given capacity.
	init with_capacity(cap: Int)
	do
		assert cap >= 0
		_items = new CString(cap)
		capacity = cap
		_byte_length = 0
	end

	redef fun append(s)
	do
		if s.is_empty then return
		var sl = s.byte_length
		var nln = _byte_length + sl
		enlarge(nln)
		if s isa FlatText then
			s._items.copy_to(_items, sl, s.first_byte, _byte_length)
		else
			for i in s.substrings do append i
			return
		end
		_byte_length = nln
		_length += s.length
	end

	# Copies the content of self in `dest`
	fun copy(start: Int, len: Int, dest: Buffer, new_start: Int)
	do
		var self_chars = self.chars
		var dest_chars = dest.chars
		for i in [0..len-1] do
			dest_chars[new_start+i] = self_chars[start+i]
		end
	end

	redef fun substring(from, count)
	do
		assert count >= 0
		if from < 0 then from = 0
		if (from + count) > _length then count = _length - from
		if count <= 0 then return new Buffer
		var its = _items
		var bytefrom = its.char_to_byte_index(from)
		var byteto = its.char_to_byte_index(count + from - 1)
		byteto += its.char_at(byteto).u8char_len - 1
		var byte_length = byteto - bytefrom + 1
		var r_items = new CString(byte_length)
		its.copy_to(r_items, byte_length, bytefrom, 0)
		return new FlatBuffer.with_infos(r_items, byte_length, byte_length, count)
	end

	redef fun append_substring_impl(s, from, length) do
		if length <= 0 then return
		if not s isa FlatText then
			super
			return
		end
		var sits = s._items
		var bytest = s.char_to_byte_index(from)
		var bytend = s.char_to_byte_index(from + length - 1)
		var btln = bytend - bytest + sits.char_at(bytend).u8char_len
		enlarge(btln + _byte_length)
		sits.copy_to(_items, btln, bytest, _byte_length)
		_byte_length += btln
		_length += length
	end

	redef fun remove_at(p, len) do
		if len == null then len = 1
		if len == 0 then return
		var its = _items
		var bst = char_to_byte_index(p)
		var bend = char_to_byte_index(p + len - 1)
		bend += its.char_at(bend).u8char_len
		var blen = bend - bst
		lshift_bytes(bend, bend - bst)
		byte_length -= blen
		length -= len
	end

	redef fun reverse
	do
		written = false
		var ns = new FlatBuffer.with_capacity(capacity)
		for i in chars.reverse_iterator do ns.add i
		_items = ns._items
	end

	redef fun times(repeats)
	do
		var bln = _byte_length
		var x = new FlatString.full(_items, bln, 0, _length)
		for i in [1 .. repeats[ do
			append(x)
		end
	end

	redef fun upper
	do
		if written then reset
		for i in [0 .. _length[ do self[i] = self[i].to_upper
	end

	redef fun lower
	do
		if written then reset
		for i in [0 .. _length[ do self[i] = self[i].to_lower
	end
end

private class FlatBufferByteReverseIterator
	super IndexedIterator[Int]

	var target: FlatBuffer

	var target_items: CString is noautoinit

	var curr_pos: Int

	init do target_items = target._items

	redef fun index do return curr_pos

	redef fun is_ok do return curr_pos >= 0

	redef fun item do return target_items[curr_pos]

	redef fun next do curr_pos -= 1

end

private class FlatBufferByteView
	super BufferByteView

	redef type SELFTYPE: FlatBuffer

	redef fun [](index) do return target._items[index]

	redef fun iterator_from(pos) do return new FlatBufferByteIterator(target, pos)

	redef fun reverse_iterator_from(pos) do return new FlatBufferByteReverseIterator(target, pos)

end

private class FlatBufferByteIterator
	super IndexedIterator[Int]

	var target: FlatBuffer

	var target_items: CString is noautoinit

	var curr_pos: Int

	init do if isset target._items then target_items = target._items

	redef fun index do return curr_pos

	redef fun is_ok do return curr_pos < target._byte_length

	redef fun item do return target_items[curr_pos]

	redef fun next do curr_pos += 1

end

private class FlatBufferCharReverseIterator
	super IndexedIterator[Char]

	var target: FlatBuffer

	var curr_pos: Int

	redef fun index do return curr_pos

	redef fun is_ok do return curr_pos >= 0

	redef fun item do return target[curr_pos]

	redef fun next do curr_pos -= 1

end

private class FlatBufferCharView
	super BufferCharView

	redef type SELFTYPE: FlatBuffer

	redef fun [](index) do return target[index]

	redef fun []=(index, item)
	do
		assert index >= 0 and index <= length
		if index == length then
			add(item)
			return
		end
		target[index] = item
	end

	redef fun push(c)
	do
		target.add(c)
	end

	redef fun add(c)
	do
		target.add(c)
	end

	fun enlarge(cap: Int)
	do
		target.enlarge(cap)
	end

	redef fun append(s)
	do
		var s_length = s.length
		if target.capacity < s.length then enlarge(s_length + target._length)
		for i in s do target.add i
	end

	redef fun iterator_from(pos) do return new FlatBufferCharIterator(target, pos)

	redef fun reverse_iterator_from(pos) do return new FlatBufferCharReverseIterator(target, pos)

end

private class FlatBufferCharIterator
	super IndexedIterator[Char]

	var target: FlatBuffer

	var max: Int is noautoinit

	var curr_pos: Int

	init do max = target._length - 1

	redef fun index do return curr_pos

	redef fun is_ok do return curr_pos <= max

	redef fun item do return target[curr_pos]

	redef fun next do curr_pos += 1

end

redef class CString

	# Get a `String` from the data at `self` copied into Nit memory
	#
	# Require: `self` is a null-terminated string.
	redef fun to_s do return to_s_unsafe

	# Get a `String` from `byte_length` bytes at `self` copied into Nit memory
	#
	# The string is cleaned.
	fun to_s_with_length(byte_length: Int): String do return to_s_unsafe(byte_length)

	redef fun to_s_unsafe(byte_length, char_length, copy, clean)
	do
		byte_length = byte_length or else cstring_length
		clean = clean or else true
		copy = copy or else true

		# Clean?
		var str = null
		if clean then
			str = clean_utf8(byte_length)
			char_length = str.length
		else
			char_length = char_length or else utf8_length(0, byte_length)
		end

		# Copy? (if not already copied by `clean_utf8`)
		if copy and (str == null or str.items == self) then
			var new_cstr = new CString(byte_length + 1)
			copy_to(new_cstr, byte_length, 0, 0)
			new_cstr[byte_length] = 0
			str = new FlatString.full(new_cstr, byte_length, 0, char_length)
		end

		if str == null then
			str = new FlatString.full(self, byte_length, 0, char_length)
		end

		return str
	end

	# Cleans a CString if necessary
	fun clean_utf8(len: Int): FlatString do
		var replacements: nullable Array[Int] = null
		var end_length = len
		var pos = 0
		var chr_ln = 0
		var rem = len
		while rem > 0 do
			while rem >= 4 do
				var i = fetch_4_chars(pos)
				if i & 0x80808080u32 != 0u32 then break
				pos += 4
				chr_ln += 4
				rem -= 4
			end
			if rem == 0 then break
			var b = self[pos]
			if b & 0x80 == 0x00 then
				pos += 1
				chr_ln += 1
				rem -= 1
				continue
			end
			var nxst = length_of_char_at(pos)
			var ok_st: Bool
			if nxst == 1 then
				ok_st = b & 0x80 == 0
			else if nxst == 2 then
				ok_st = b & 0xE0 == 0xC0
			else if nxst == 3 then
				ok_st = b & 0xF0 == 0xE0
			else
				ok_st = b & 0xF8 == 0xF0
			end
			if not ok_st then
				if replacements == null then replacements = new Array[Int]
				replacements.add pos
				end_length += 2
				pos += 1
				rem -= 1
				chr_ln += 1
				continue
			end
			var ok_c: Bool
			var c = char_at(pos)
			var cp = c.code_point
			if nxst == 1 then
				ok_c = cp >= 0 and cp <= 0x7F
			else if nxst == 2 then
				ok_c = cp >= 0x80 and cp <= 0x7FF
			else if nxst == 3 then
				ok_c = cp >= 0x800 and cp <= 0xFFFF
				ok_c = ok_c and not (cp >= 0xD800 and cp <= 0xDFFF) and cp != 0xFFFE and cp != 0xFFFF
			else
				ok_c = cp >= 0x10000 and cp <= 0x10FFFF
			end
			if not ok_c then
				if replacements == null then replacements = new Array[Int]
				replacements.add pos
				end_length += 2
				pos += 1
				chr_ln += 1
				rem -= 1
				continue
			end
			var clen = c.u8char_len
			pos += clen
			rem -= clen
			chr_ln += 1
		end
		var ret = self
		if end_length != len then
			ret = new CString(end_length)
			var old_repl = 0
			var off = 0
			var repls = replacements.as(not null)
			var r = repls.items.as(not null)
			var imax = repls.length
			for i in [0 .. imax[ do
				var repl_pos = r[i]
				var chkln = repl_pos - old_repl
				copy_to(ret, chkln, old_repl, off)
				off += chkln
				ret[off] = 0xEF
				ret[off + 1] = 0xBF
				ret[off + 2] = 0xBD
				old_repl = repl_pos + 1
				off += 3
			end
			copy_to(ret, len - old_repl, old_repl, off)
		end
		return new FlatString.full(ret, end_length, 0, chr_ln)
	end

	# Sets the next bytes at position `pos` to the value of `c`, encoded in UTF-8
	#
	# Very unsafe, make sure to have room for this char prior to calling this function.
	private fun set_char_at(pos: Int, c: Char) do
		var cp = c.code_point
		if cp < 128 then
			self[pos] = cp
			return
		end
		var ln = c.u8char_len
		if ln == 2 then
			self[pos] = 0xC0 | ((cp & 0x7C0) >> 6)
			self[pos + 1] = 0x80 | (cp & 0x3F)
		else if ln == 3 then
			self[pos] = 0xE0 | ((cp & 0xF000) >> 12)
			self[pos + 1] = 0x80 | ((cp & 0xFC0) >> 6)
			self[pos + 2] = 0x80 | (cp & 0x3F)
		else if ln == 4 then
			self[pos] = 0xF0 | ((cp & 0x1C0000) >> 18)
			self[pos + 1] = 0x80 | ((cp & 0x3F000) >> 12)
			self[pos + 2] = 0x80 | ((cp & 0xFC0) >> 6)
			self[pos + 3] = 0x80 | (cp & 0x3F)
		end
	end
end

redef class Int
	# return displayable int in base 10 and signed
	#
	#     assert 1.to_s            == "1"
	#     assert (-123).to_s       == "-123"
	redef fun to_s do
		# Fast case for common numbers
		if self == 0 then return "0"
		if self == 1 then return "1"

		var nslen = int_to_s_len
		var ns = new CString(nslen + 1)
		ns[nslen] = 0
		native_int_to_s(ns, nslen + 1)
		return new FlatString.full(ns, nslen, 0, nslen)
	end
end

redef class Array[E]

	# Fast implementation
	redef fun plain_to_s
	do
		var l = _length
		if l == 0 then return ""
		var its = _items.as(not null)
		var first = its[0]
		if l == 1 then if first == null then return "" else return first.to_s
		var na = new NativeArray[String](l)
		var i = 0
		var sl = 0
		var mypos = 0
		while i < l do
			var itsi = its[i]
			if itsi == null then
				i += 1
				continue
			end
			var tmp = itsi.to_s
			sl += tmp.byte_length
			na[mypos] = tmp
			i += 1
			mypos += 1
		end
		var ns = new CString(sl + 1)
		ns[sl] = 0
		i = 0
		var off = 0
		while i < mypos do
			var tmp = na[i]
			if tmp isa FlatString then
				var tpl = tmp._byte_length