Elepffwdsff

korsygfhrtzangaiide Elepffwdsff

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
 "http://www.w3.org/TR/html4/strict.dtd">
<html>

<head>
<meta name="description" content="LuaSocket: LTN12 support">
<meta name="keywords" content="Lua, LuaSocket, Filters, Source, Sink,
Pump, Support, Library">
<title>LuaSocket: LTN12 module</title>
<link rel="stylesheet" href="reference.css" type="text/css">
</head>

<body>

<div class="header">
<hr>
<center>
<table summary="LuaSocket logo">
<tr><td align="center"><a href="http://www.lua.org">
<img width="128" height="128" border="0" alt="LuaSocket" src="luasocket.png">
</a></td></tr>
<tr><td align="center" valign="top">Network support for the Lua language
</td></tr>
</table>

<a href="index.html">home</a> &middot;
<a href="index.html#download">download</a> &middot;
<a href="installation.html">installation</a> &middot;
<a href="introduction.html">introduction</a> &middot;
<a href="reference.html">reference</a>

</center>
<hr>
</div>

The <tt>ltn12</tt> namespace implements the ideas described in
<a href="http://lua-users.org/wiki/FiltersSourcesAndSinks">
LTN012, Filters sources and sinks</a>. This manual simply describes the
functions. Please refer to the LTN for a deeper explanation of the
functionality provided by this module.

To obtain the <tt>ltn12</tt> namespace, run:

<pre class="example">
-- loads the LTN21 module
local ltn12 = require("ltn12")
</pre>

<h3 id="filter">Filters</h3>

ltn12.filter.chain(filter1, filter2
[, ... filterN])

Returns a filter that passes all data it receives through each of a
series of given filters.

<tt>Filter1</tt> to <tt>filterN</tt> are simple
filters.

The function returns the chained filter.

The nesting of filters can be arbitrary. For instance, the useless filter
below doesn't do anything but return the data that was passed to it,
unaltered.

<pre class="example">
-- load required modules
local ltn12 = require("ltn12")
local mime = require("mime")

-- create a silly identity filter
id = ltn12.filter.chain(
 mime.encode("quoted-printable"),
 mime.encode("base64"),
 mime.decode("base64"),
 mime.decode("quoted-printable")
)
</pre>

ltn12.filter.cycle(low [, ctx, extra])

Returns a high-level filter that cycles though a low-level filter by
passing it each chunk and updating a context between calls.

<tt>Low</tt> is the low-level filter to be cycled,
<tt>ctx</tt> is the initial context and <tt>extra</tt> is any extra
argument the low-level filter might take.

The function returns the high-level filter.

<pre class="example">
-- load the ltn12 module
local ltn12 = require("ltn12")

-- the base64 mime filter factory
encodet['base64'] = function()
 return ltn12.filter.cycle(b64, "")
end
</pre>

<h3 id="pump">Pumps</h3>

ltn12.pump.all(source, sink)

Pumps all data from a <tt>source</tt> to a <tt>sink</tt>.

If successful, the function returns a value that evaluates to
<tt>true</tt>. In case
of error, the function returns a <tt>false</tt> value, followed by an error message.

ltn12.pump.step(source, sink)

Pumps one chunk of data from a <tt>source</tt> to a <tt>sink</tt>.

<h3 id="sink">Sinks</h3>

ltn12.sink.chain(filter, sink)

Creates and returns a new sink that passes data through a <tt>filter</tt> before sending it to a given <tt>sink</tt>.

ltn12.sink.error(message)

Creates and returns a sink that aborts transmission with the error
<tt>message</tt>.

ltn12.sink.file(handle, message)

Creates a sink that sends data to a file.

<tt>Handle</tt> is a file handle. If <tt>handle</tt> is <tt>nil</tt>,
<tt>message</tt> should give the reason for failure.

The function returns a sink that sends all data to the given <tt>handle</tt>
and closes the file when done, or a sink that aborts the transmission with
the error <tt>message</tt>

In the following example, notice how the prototype is designed to
fit nicely with the <tt>io.open</tt> function.

<pre class="example">
-- load the ltn12 module
local ltn12 = require("ltn12")

-- copy a file
ltn12.pump.all(
 ltn12.source.file(io.open("original.png", "rb")),
 ltn12.sink.file(io.open("copy.png", "wb"))
)
</pre>

ltn12.sink.null()

Returns a sink that ignores all data it receives.

ltn12.sink.simplify(sink)

Creates and returns a simple sink given a fancy <tt>sink</tt>.

ltn12.sink.table([table])

Creates a sink that stores all chunks in a table. The chunks can later be
efficiently concatenated into a single string.

<tt>Table</tt> is used to hold the chunks. If
<tt>nil</tt>, the function creates its own table.

The function returns the sink and the table used to store the chunks.

<pre class="example">
-- load needed modules
local http = require("socket.http")
local ltn12 = require("ltn12")

-- a simplified http.get function
function http.get(u)
 local t = {}
 local respt = request{
 url = u,
 sink = ltn12.sink.table(t)
 }
 return table.concat(t), respt.headers, respt.code
end
</pre>

<h3 id="source">Sources</h3>

ltn12.source.cat(source1 [, source2, ...,
sourceN])

Creates a new source that produces the concatenation of the data produced
by a number of sources.

<tt>Source1</tt> to <tt>sourceN</tt> are the original
sources.

The function returns the new source.

ltn12.source.chain(source, filter)

Creates a new <tt>source</tt> that passes data through a <tt>filter</tt>
before returning it.

The function returns the new source.

ltn12.source.empty()

Creates and returns an empty source.

ltn12.source.error(message)

Creates and returns a source that aborts transmission with the error
<tt>message</tt>.

ltn12.source.file(handle, message)

Creates a source that produces the contents of a file.

<tt>Handle</tt> is a file handle. If <tt>handle</tt> is <tt>nil</tt>,
<tt>message</tt> should give the reason for failure.

The function returns a source that reads chunks of data from
given <tt>handle</tt> and returns it to the user,
closing the file when done, or a source that aborts the transmission with
the error <tt>message</tt>

In the following example, notice how the prototype is designed to
fit nicely with the <tt>io.open</tt> function.

<pre class="example">
-- load the ltn12 module
local ltn12 = require("ltn12")

-- copy a file
ltn12.pump.all(
 ltn12.source.file(io.open("original.png", "rb")),
 ltn12.sink.file(io.open("copy.png", "wb"))
)
</pre>

ltn12.source.simplify(source)

Creates and returns a simple source given a fancy <tt>source</tt>.

ltn12.source.string(string)

Creates and returns a source that produces the contents of a
<tt>string</tt>, chunk by chunk.

ltn12.source.table(table)

Creates and returns a source that produces the numerically-indexed values of a <tt>table</tt> successively beginning at 1. The source returns nil (end-of-stream) whenever a nil value is produced by the current index, which proceeds forward regardless.

<div class="footer">
<hr>
<center>

<a href="index.html">home</a> &middot;
<a href="index.html#down">download</a> &middot;
<a href="installation.html">installation</a> &middot;
<a href="introduction.html">introduction</a> &middot;
<a href="reference.html">reference</a>



Last modified by Diego Nehab on 
Thu Apr 20 00:25:41 EDT 2006


</center>
</div>

</body>
</html>