|
Pope John VIIIaka Pope Joan, Pope JoannaThe Roman Catholic Church has this official position on the subject of women as priests:"The female sex is in some respects inferior to the male sex, both as regards body and soul. ... If the two sexes are designed by nature for a homogeneous organic co-operation, then the leading position or a social pre-eminence must necessarily fall to one of them. Man is called by the Creator to this position of leader, as is shown by his entire bodily and intellectual make-up."  But it wasn't always like that. In the early days of the church, there were women priests and bishops. Those women have been retroactively declared heretics, but the Inquisition prefers simply not to talk about Pope John VIII, also known as Pope Joan (or less frequently as Joanna). Holy Victor/Victoria, Batman! There is a reasonable body of evidence to suggest that John was Joan, or at least as much credible evidence as there is to support other historical myths like the crucifixion of Jesus Christ or the construction of Alexandria. You have to keep in mind that history, as with all forms of consensus reality, isn't a rock-solid and unchangeable edifice. It's more like an impressionist reproduction of a cubist painting -- all you can do is squint and then take your best stab at it. So take a good look at this portrait of Pope John VIII, squint, and figure out whether he looks like a she to you. Proceed to tell everyone your version of the story, and be damned anyone who disagrees! What little we know for sure indicates that John VIII was a controversial pope, but this isn't exactly a point of great distinction in the ninth century church, when intramural political battles were the rule of the day. His/her greatest enemy was some schmuck cardinal named Formosus. Formosus was excommunicated by John/Joan, recommunicated after his/her death, subsequently elected pope himself, died, then was re-excommunicated, his grave desecrated and his papacy revoked posthumously, all of which was subsequently reversed a couple of decades later. However, this is not Formosus' story. The official Catholic Church account of John/Joan's regime states that "All modern historians are agreed that John was one of the greatest of the great popes who sat on the chair of Peter during the ninth century. Some, however, on what would seem to be insufficient grounds, regard him as cruel, passionate, worldly-minded, and inconstant."  Perhaps the story of this gender confusion originated with one of these enemies, but at any rate, the legend states that one day around 855 A.D. a funny thing happened on the way to St. Peter's basilica: Pope John had to stop alongside the road in order to deliver a baby -- his/her own as it happened. Various legends lay out the possible fate of Joan/John after this not-so-blessed event.   Others claim Joan was exiled or sent to a nunnery. The official Vatican story is that John-not-Joan was murdered by a political enemy and family member who hammered him to death, with no particular issue of gender arising during this process. From these historical scraps, things go the usual murky route from legend to fact to distortion to just plain confusion. It appears that the church gave a wink and a nod to the story of Pope Joan for a couple of centuries before disavowing it. There are references in medieval Vatican manuscripts to a statue of the female pope with her child, and various legends are tied to the story, albeit not very convincingly. One of the most entertaining of these claims that Papal Thrones were outfitted with a hole in the seat so that cardinals could conveniently spot-check the gender of the pontiff. This seems needlessly elaborate, when a simple pantsing would do the trick, but it is rather amusing to contemplate. Eventually, the Church did disavow the whole Joan story, as they do to this day. Some claim that Joan was the archetypical model for the High Priestess card in the Tarot, but most of these date the influence to the 14th century, which was a few centuries before the Tarot is documented to have existed. In the 20th century, Pope Joan became a heroine to the feminist movement, inspiring people everywhere to... well, OK, she didn't really inspire much in the way of specific aspirations, since the Vatican still won't let a woman become a priest, much less pope. One thing she did inspire was a movie, 1972's Pope Joan, a whopping two-hour plus epic starring Liv Ullman as the Lady Pope. (The film is directed by Michael Anderson, who would go on to such cinematic milestones as Logan's Run and Orca). The movie features Ullman as a "me generation" hipster chick who is hypnotized to recall her past life as Pope Joan, which involved a lot of priestly and monastic rape followed by consensual priestly and monastic sex, leading to the fabled birth scene and obligatory stoning. So there you can clearly see that all sorts of iniquity ensues when you try to deny the superiority of the male "entire bodily and intellectual make-up." Aren't you glad the church has remained untainted by womanfolk ever since?
|


{% load static %} {% csrf_token %}
Sign up
Same as above
Are you a seller? :
Yes
No
I agree all statements in
Terms of service
I am already member


protected class SnapshotDeletionPolicy.SnapshotCommitPoint extends IndexCommit
| Modifier and Type | Field and Description |
|---|---|
protected
IndexCommit
|
cp
|
| Modifier | Constructor and Description |
|---|---|
protected
|
SnapshotDeletionPolicy.SnapshotCommitPoint
(
IndexCommit
cp)
|
| Modifier and Type | Method and Description |
|---|---|
void
|
delete
()
Delete this commit point.
|
Directory
|
getDirectory
()
Returns the
Directory
for the index.
|
Collection
<
String
>
|
getFileNames
()
Returns all index files referenced by this commit point.
|
long
|
getGeneration
()
Returns the generation (the _N in segments_N) for this
IndexCommit
|
int
|
getSegmentCount
()
Returns number of segments referenced by this commit.
|
String
|
getSegmentsFileName
()
Get the segments file (
segments_N
) associated
with this commit point.
|
Map
<
String
,
String
>
|
getUserData
()
Returns userData, previously passed to
IndexWriter.commit(Map)
for this commit.
|
long
|
getVersion
()
Returns the version for this IndexCommit.
|
boolean
|
isDeleted
()
|
protected boolean
|
shouldDelete
(
String
segmentsFileName)
Returns true if this segment can be deleted.
|
String
|
toString
()
|
compareTo
,
equals
,
getTimestamp
,
hashCode
protected IndexCommit cp
protected SnapshotDeletionPolicy.SnapshotCommitPoint( IndexCommit cp)
protected boolean shouldDelete( String segmentsFileName)
public void delete()
IndexCommit
Upon calling this, the writer is notified that this commit point should be deleted.
Decision that a commit-point should be deleted is taken by the
IndexDeletionPolicy
in effect
and therefore this should only be called by its
onInit()
or
onCommit()
methods.
delete
in class
IndexCommit
public Directory getDirectory()
IndexCommit
Directory
for the index.
getDirectory
in class
IndexCommit
public Collection < String > getFileNames() throws IOException
IndexCommit
getFileNames
in class
IndexCommit
IOException
public long getGeneration()
IndexCommit
getGeneration
in class
IndexCommit
public String getSegmentsFileName()
IndexCommit
segments_N
) associated
with this commit point.
getSegmentsFileName
in class
IndexCommit
public Map < String , String > getUserData() throws IOException
IndexCommit
IndexWriter.commit(Map)
for this commit. Map is
String -> String.
getUserData
in class
IndexCommit
IOException
public long getVersion()
IndexCommit
IndexReader.getVersion()
would
return if it were opened on this commit.
getVersion
in class
IndexCommit
public boolean isDeleted()
isDeleted
in class
IndexCommit
public int getSegmentCount()
IndexCommit
getSegmentCount
in class
IndexCommit


Vincent Williamson
31
iOS Developer
Washington
Joseph Smith
27
Project Manager
Somerville, MA
Justin Black
26
Front-End Developer
Los Angeles
Sean Guzman
25
Web Designer
San Francisco
Keith Carter
20
Graphic Designer
New York, NY
Austin Medina
32
Photographer
New York
Vincent Williamson
31
iOS Developer
Washington
Joseph Smith
27
Project Manager
Somerville, MA


List-Like object. Summary of ESM watchlists.
>>> from msiempy import WatchlistManager >>> wl_list = WatchlistManager() >>> wl = wl_list.search('test_Watchlist')[0] >>> wl.add_values(['<IP_ADDRESS>', '<IP_ADDRESS>', '<IP_ADDRESS>'])
Watchlist
| Method | __init__ | Initialize the watchlist manager. |
| Instance Variable | data | Undocumented |
| Method | load_details | Load the details of existing watchlists. |
| Method | refresh | Reloads the watchlist summary. |
| Method | add | Create a static watchlist. |
| Method | remove | Remove watchlist(s). |
| Method | get_wl_types | Get a list of watchlist types. |
| Method | _init_watchlist_summary | Loads the watchlist summary. |
Inherited from NitroList:
| Method | __str__ | str(obj) -> return text string. |
| Method | keys | List items keys. Every items should have the same set of keys. |
| Method | get_text | Return a csv or table string representation of the list |
| Method | text | Defaut table string, a shorcut to get_text() with no arguments. |
| Method | json | JSON list of dicts representing the list. |
| Method | search | Search elements in the list with a regex pattern |
| Method | perform | Wrapper to execute a function on the list of elements |
| Static Method | _confirm_func | Ask user inut to confirm the calling of func on elements . |
Inherited from NitroObject (via NitroList):
| Class | NitroJSONEncoder | Custom JSON encoder that will use the approprtiate propertie depending of the type of NitroObject. TODO support json json dumping of QueryFilers, may be by making them inherits from NitroDict. |
| Instance Variable | nitro | msiempy.core.session.NitroSession object. Interface to the SIEM. |
Create a static watchlist.
msiempy.watchlist.WatchlistManager.get_wl_types
Most common types are: "IPAddress", "Hash", "SHA1", "DSIDSigID", "Port", "MacAddress", "NormID", "AppID", "CommandID", "DomainID", "HostID", "ObjectID", "Filename", "File_Hash".Remove watchlist(s).
wl_id_list
(list[int]
): list of watchlist IDs. Example: [1, 2, 3]
.


@Exported(value=true)
See: Description
| Interface | Description |
|---|---|
| ResourceApprover |
A ResourceApprover is a callback to approve resource
requests.
|
| ResourceContext |
A set of ResourceMeters that accumulate resource usage by threads.
|
| ResourceId |
ResourceId provides a name and accuracy for a resource instance.
|
| ResourceMeter |
A resource meter with a current value and a ResourceType.
|
| ResourceRequest |
A ResourceRequest is an interface to allocate or release resources.
|
| Class | Description |
|---|---|
| BoundedMeter |
A BoundedMeter enforces an upper bound, provides an approver callback for
changes and allocates from an optional parent.
|
| NotifyingMeter |
A NotifyingMeter provides an approver callback for changes and
allocates from an optional parent.
|
| ResourceContextFactory |
The ResourceContextFactory provides access to ResourceContext functions.
|
| ResourceType |
A ResourceType with a name.
|
| SimpleMeter |
A SimpleMeter counts resource requests and releases
and allocates from an optional parent.
|
| ThrottledMeter |
A ThrottledMeter with bandwidth limit, an approver callback for requests and
allocates from an optional parent.
|
| Enum | Description |
|---|---|
| ResourceAccuracy |
ResourceAccuracy reflects the accuracy of an amount being requested though a
ResourceMeter.
|
| Exception | Description |
|---|---|
| ResourceRequestDeniedException |
ResourceRequestDeniedException indicates a resource exception.
|
The architecture identifies three major components:
ResourceContext
.
ResourceContextFactory
provides access to
ResourceContexts
and provides the main entry point to the API.
ResourceContext
contains a set of
ResourceMeters that
track usage of resources by threads bound to the ResourceContext.
ResourceType
s are used to identify a type of resource.
For example FILE_OPEN opening a file
or SOCKET_WRITE writing to a socket
.
ResourceMeter
s track the usage of a ResourceType.
The ResourceMeters SimpleMeter
,
NotifyingMeter
,
BoundedMeter
, and ThrottledMeter
count the resource
use and approve, throttle, or deny resource use.
ResourceId
s identify specific resources and the accuracy
of the measurements.
ResourceApprover
is an interface implemented by the
resource manager and is notified of resource use. The response
from the resource manager determines whether the resource is approved,
limited or denied.
ResourceRequest
to the matching ResourceType. The resources instrumented include:
System.err
, System.in
, System.out
ResourceContext
.
A resource manager and resource management policy are not included.
Resource management is a security sensitive API and access to the API is allowed
by a SecurityManager, if any, and the
RuntimePermission("jdk.management.resource.getResourceContextFactory")
.
Resource tracking is enabled via the command line options
-XX:+ResourceManagement
and
-XX:ResourceManagementSampleInterval=nn (milliseconds)
and
-XX:+UseG1GC
as appropriate to provide retained heap amounts.
The use of the application thread is sensitive. The resource manager
must not interfere with the application and must avoid calling functions
that might cause recursive calls to the resource management instrumentation.
Implementations of the ResourceRequest and
ResourceApprover interfaces
must be kept short, lightweight and be self contained. Calls
through these interfaces occur very frequently and can impact performance
of all instrumented resources.
For example, calling System.out.println
to
insert debugging output results in a recursive call. It can
cause unintentional loops and/or be a victim of incomplete class initialization.
Symptoms may include StackOverflowError or
ExceptionInInitializerError.
For resource allocation, the updates to the meters usually occur before the action is performed to allow the resource manager policy to slow or deny use of the resource. The release of resources happens after the resources are released so the resource counts are not prematurely decremented. For resources that have been allocated but not used, the remainder is released. For example, if a SecurityException occurs on opening a file, the count of open file count is reduced, or if when reading a file, if the amount of data read from the file is less than requested, the bytes not read reduce the count.
AsynchronousFileChannel
, FileChannel
,
FileInputStream
, FileOutputStream
,
and RandomAccessFile
. The ResourceId
reported is the pathname provided to the API except for AsynchronousFileChannel
where it is the FileDescriptor
number or handle. The methods below are
instrumented to accumulate the resource usage to the indicated
ResourceMeters using the thread of the
application. The resource consumption can be denied by the ResourceApprover
or ResourceMeter by returning zero or
throwing a ResourceRequestDeniedException.
When denied, the I/O operation fails with an IOException.
When a file is opened the ResourceContext is remembered until it is closed.
The close of the channel or file reduces the count in the same ResourceContext
that opened it.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
FILE_OPEN |
AsynchronousFileChannel.open , FileChannel.open , FileInputStream , FileOutputStream , RandomAccessFile |
AsynchronousFileChannel.close , FileChannel.close , FileInputStream.close , FileOutputStream.close , RandomAccessFile.close |
1 |
FILE_READ |
AsynchronousFileChannel.read , FileChannel.read , FileInputStream.read , RandomAccessFile.read methods, System.in.read |
requested number of bytes to read less number actually read | length |
FILE_WRITE |
AsynchronousFileChannel.write , FileChannel.write , FileOutputStream.write , RandomAccessFile.write methods,System.err print and write methods,System.out print and write methods |
Exception | length |
When a file descriptor is allocated the ResourceContext is remembered until it is closed.
The close of the file descriptor reduces the count in the same ResourceContext
that opened it.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
FILEDESCRIPTOR_OPEN |
AsynchronousFileChannel.open , AsynchronousServerSocketChannel.accept , AsynchronousServerSocketChannel.open , AsynchronousSocketChannel.open , DatagramChannel.open , DatagramSocket , FileChannel.open , FileInputStream , FileOutputStream , RandomAccessFile , ServerSocketChannel.accept , ServerSocketChannel.open , ServerSocket (if binding), ServerSocket.accept , ServerSocket.bind (if not bound), Socket (if connecting), Socket.connect (if not connected) SocketChannel.open |
AsynchronousFileChannel.close , AsynchronousServerSocketChannel.close , AsynchronousSocketChannel.close , DatagramChannel.close , DatagramSocket.close , FileChannel.close , FileInputStream.close , FileOutputStream.close ,RandomAccessFile.close ,ServerSocketChannel.close ,ServerSocket.close ,Socket.close ,SocketChannel.close |
1 |
ServerSocket
s and Socket
s this occurs when the socket is
bound or connected, respectively. Binding or connecting may occur either
during instantiation of the socket or subsequent thereto.
When a socket is opened the ResourceContext is remembered until it is closed.
The close of the channel socket reduces the count in the same ResourceContext
that opened it.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
SOCKET_OPEN |
AsynchronousServerSocketChannel.accept , AsynchronousServerSocketChannel.bind (if not bound), AsynchronousSocketChannel.bind (if not bound), AsynchronousSocketChannel.connect (if not bound), ServerSocketChannel.bind (if not bound), ServerSocket.accept , ServerSocket.bind (if not bound), Socket.bind (if not bound), Socket.connect (if not bound), SocketChannel.bind (if not bound), SocketChannel.connect (if not bound) |
AsynchronousServerSocketChannel.close , AsynchronousSocketChannel.close , ServerSocketChannel.close , ServerSocket.close , Socket.close , SocketChannel.close |
1 |
SOCKET_READ |
AsynchronousSocketChannel.read , Socket.getInputStream().read ,SocketChannel.read |
requested number of bytes to read less number actually read | length |
SOCKET_WRITE |
AsynchronousSocketChannel.write , Socket.getOutputStream().write , SocketChannel.write |
Exception | length |
SOCKET_OPEN
resource count
occurs when the object is bound, not when it is created. Binding may occur
while connecting if the socket was not previously bound.
DatagramChannel
and DatagramSocket
classes.
The ResourceId reported is the address of the local network port.
The methods below are instrumented to accumulate the resource usage to
the indicated ResourceMeters using the thread of the application.
The resource consumption can be denied by the ResourceApprover or
ResourceMeter by returning zero or
throwing a ResourceRequestDeniedException.
When denied, the I/O operation fails with an IOException.
When a DatagramSocket is opened the ResourceContext is remembered until it is closed.
The close of the channel or socket reduces the count in the same ResourceContext
that opened it.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
DATAGRAM_OPEN |
DatagramChannel.bind , DatagramChannel.connect , DatagramChannel.send , DatagramSocket.bind , DatagramSocket.connect , |
DatagramChannel.close , DatagramSocket.close |
1 |
DATAGRAM_RECEIVED |
DatagramChannel.read , DatagramChannel.receive , DatagramSocket.receive |
Exception | 1 |
DATAGRAM_SENT |
DatagramChannel.send , DatagramChannel.write , DatagramSocket.send |
Exception | 1 |
DATAGRAM_READ |
DatagramChannel.read , DatagramChannel.receive , DatagramSocket.receive |
requested number of bytes to read less number actually read | +datagram length |
DATAGRAM_WRITE |
DatagramChannel.send , DatagramChannel.write , DatagramSocket.send |
Exception | +datagram length |
DATAGRAM_OPEN
resource count
occurs when the object is bound, not when it is created. Binding may occur
while connecting or, in the case of DatagramChannel
, while sending,
if the socket was not previously bound.
THREAD_CREATED
meters are updated.
Thread creation is prevented if an exception is thrown.
If the amount returned from the meter is zero, a
ResourceRequestDeniedException is thrown.
When a thread is unbound from a ResourceContext, the accumulated CPU time
usage since the thread was bound to the context is applied to the
THREAD_CPU
ResourceMeter in the
ResourceContext
bound to the thread.
The update is performed using the thread being unbound.
Threads that are not system threads are initially bound to the
unassignedContext
.
New threads are implicitly bound to the ResourceContext
of the thread invoking new Thread
.
The Thread's Runnable
should explicitly
bind
to the desired context as required.
Periodic updates are performed by a monitoring thread
that samples the threads active in each ResourceContext and performs
an update for the CPU time of each thread.
The ResourceApprover or
ResourceMeter actions may return zero
or throw ResourceRequestDeniedException but it is platform specific whether it
has any effect on the application consuming the resource.
The timing of updates may vary due to sampling.
The normal behavior of setting granularity of a THREAD_CPU
meter
applies, notifications occur when crossing granularity boundaries.
The sample interval is set by the implementation
using the command line switch -XX:ResourceManagementSampleInterval=nn
.
The default is to sample every 100 milliseconds (.1 second).
The sampling can be disabled by providing an argument of 0 (zero)
.
If the argument is less than zero, the default is used.
The ResourceId reported for
THREAD_CREATED
and
THREAD_CPU
is
the threadID
formatted as in Long.toString(threadID)
.
When a thread is created the ResourceContext
is remembered until it exits.
The exit of the thread reduces the count of created threads in the same ResourceContext
that opened it.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
THREAD_CPU |
Threads running | never | nanoseconds |
THREAD_CREATED |
Thread construction | Thread exit | count |
When a thread is unbound from a ResourceContext, the accumulated heap
allocation usage since the thread was bound to the context is applied to the
HEAP_ALLOCATED
ResourceMeter
in the
ResourceContext bound to the thread.
The update is performed using the thread being unbound.
The HEAP_ALLOCATED
value sample interval is the same as the
THREAD_CPU
meter.
The ResourceId is the threadId
for
HEAP_ALLOCATED
and is reported
for each thread individually.
For HEAP_RETAINED
usage, updates occur as the result of garbage collector
activity. When a GC phase completes, the meters for HEAP_RETAINED
are updated.
The accuracy of the retained heap amounts are available from the
ResourceId.getAccuracy
method as a
ResourceAccuracy
value.
The ResourceApprover or
ResourceMeter actions may return zero
or throw ResourceRequestDeniedException but it is platform specific whether it
has any effect on the application consuming the resource.
HEAP_RETAINED updates with
ResourceAccuracy.HIGH or
ResourceAccuracy.HIGHEST are always delivered without regard
to the granularity set on the meter.
The timing of updates may vary due to sampling and GC behavior.
The ResourceId for HEAP_RETAINED
is "Heap"
.
ResourceType |
Incremented | Decremented | Amount |
|---|---|---|---|
HEAP_ALLOCATED |
Object allocation | never | bytes allocated (upper bound) |
HEAP_RETAINED |
On GC phase completion | On GC phase completion | bytes retained (upper bound) |
void test1() {
ResourceContextFactory rfactory = ResourceContextFactory.getInstance();
ResourceContext rc1 = rfactory.create("context1");
ResourceMeter writeMeter = SimpleMeter.create(ResourceType.FILE_WRITE);
rc1.addResourceMeter(writeMeter);
rc1.bindThreadContext();
try {
long bytesWritten = writeFile("example1.tmp");
assert bytesWritten == writeMeter.get() : "Expected: " + bytesWritten + ", actual: " + writeMeter.get();
} finally {
ResourceContext.unbindThreadContext();
}
}
public void test1() {
ResourceContextFactory rfactory = ResourceContextFactory.getInstance();
ResourceContext rcontext = rfactory.create("test");
SimpleMeter fileOpenMeter = SimpleMeter.create(ResourceType.FILE_OPEN);
rcontext.addResourceMeter(fileOpenMeter);
SimpleMeter fileWriteMeter = SimpleMeter.create(ResourceType.FILE_WRITE);
rcontext.addResourceMeter(fileWriteMeter);
SimpleMeter threadCPUMeter = SimpleMeter.create(ResourceType.THREAD_CPU);
rcontext.addResourceMeter(threadCPUMeter);
SimpleMeter heapAllocMeter = SimpleMeter.create(ResourceType.HEAP_ALLOCATED);
rcontext.addResourceMeter(heapAllocMeter);
AtomicLong progress = new AtomicLong();
NotifyingMeter fileReadMeter = NotifyingMeter.create(ResourceType.FILE_READ,
(ResourceMeter c, long prev, long amt, ResourceId id) -> {
// total up the lengths of the positive requests
progress.getAndAdd(Math.max(0, amt));
return amt;
});
rcontext.addResourceMeter(fileReadMeter);
rcontext.bindThreadContext();
try {
FileConsumer fc = FileConsumer.create();
fc.write();
fc.read();
} catch (IOException ioe) {
System.out.printf("ioe: %s%n", ioe);
} finally {
ResourceContext.unbindThreadContext();
}
System.out.printf(" cpu: %9d ns%n", threadCPUMeter.getValue());
System.out.printf(" file open: %9d bytes%n", fileOpenMeter.getValue());
System.out.printf(" file read: %9d bytes%n", fileReadMeter.getValue());
System.out.printf(" file write: %9d bytes%n", fileWriteMeter.getValue());
System.out.printf(" heap total: %9d bytes%n", heapAllocMeter.getValue());
System.out.printf(" progress: %9d bytes%n", progress.get());
}
Produces the output
cpu: 76960825 ns
file open: 8 bytes
file read: 82639 bytes
file write: 82639 bytes
heap total: 801624 bytes
progress: 99188 bytes
Copyright © 2014, 2019, Oracle and/or its affiliates. All rights reserved.


# Licensed under a 3-clause BSD style license - see LICENSE.rst
"""
This package contains functions for reading and writing HDF5 tables that are
not meant to be used directly, but instead are available as readers/writers in
`astropy.table`. See :ref:`table_io` for more details.
"""
from __future__ import print_function
import os
import warnings
import numpy as np
from ...utils.exceptions import AstropyUserWarning
HDF5_SIGNATURE = b'\x89HDF\r\n\x1a\n'
__all__ = ['read_table_hdf5', 'write_table_hdf5']
def _find_all_structured_arrays(handle):
"""
Find all sturctured arrays in an HDF5 file
"""
import h5py
structured_arrays = []
def append_structured_arrays(name, obj):
if isinstance(obj, h5py.Dataset) and obj.dtype.kind == 'V':
structured_arrays.append(name)
handle.visititems(append_structured_arrays)
return structured_arrays
def is_hdf5(origin, filepath, fileobj, *args, **kwargs):
if fileobj is not None:
loc = fileobj.tell()
try:
signature = fileobj.read(8)
finally:
fileobj.seek(loc)
return signature == HDF5_SIGNATURE
elif filepath is not None:
return filepath.endswith('.hdf5') or filepath.endswith('.h5')
try:
import h5py
except ImportError:
return False
else:
return isinstance(args[0], (h5py.highlevel.File, h5py.highlevel.Group))
[docs]def read_table_hdf5(input, path=None):
"""
Read a Table object from an HDF5 file
This requires `h5py <http://alfven.org/wp/hdf5-for-python/>`_ to be
installed. If more than one table is present in the HDF5 file or group, the
first table is read in and a warning is displayed.
Parameters
----------
input : str or `h5py.highlevel.File` or `h5py.highlevel.Group` or `h5py.highlevel.Dataset`
If a string, the filename to read the table from. If an h5py object,
either the file or the group object to read the table from.
path : str
The path from which to read the table inside the HDF5 file.
This should be relative to the input file or group.
"""
try:
import h5py
except ImportError:
raise Exception("h5py is required to read and write HDF5 files")
if isinstance(input, (h5py.highlevel.File, h5py.highlevel.Group)):
# If a path was specified, follow the path
if path:
try:
input = input[path]
except (KeyError, ValueError):
raise IOError("Path {0} does not exist".format(path))
# `input` is now either a group or a dataset. If it is a group, we
# will search for all structured arrays inside the group, and if there
# is one we can proceed otherwise an error is raised. If it is a
# dataset, we just proceed with the reading.
if isinstance(input, h5py.highlevel.Group):
# Find all structured arrays in group
arrays = _find_all_structured_arrays(input)
if len(arrays) == 0:
raise ValueError("no table found in HDF5 group {0}".format(path))
elif len(arrays) > 0:
path = arrays[0] if path is None else path + '/' + arrays[0]
warnings.warn("path= was not specified but multiple tables"
" are present, reading in first available"
" table (path={0})".format(path), AstropyUserWarning)
return read_table_hdf5(input, path=path)
elif not isinstance(input, h5py.highlevel.Dataset):
# If a file object was passed, then we need to extract the filename
# because h5py cannot properly read in file objects.
if hasattr(input, 'read'):
try:
input = input.name
except AttributeError:
raise TypeError("h5py can only open regular files")
# Open the file for reading, and recursively call read_table_hdf5 with
# the file object and the path.
f = h5py.File(input, 'r')
try:
return read_table_hdf5(f, path=path)
finally:
f.close()
# If we are here, `input` should be a Dataset object, which we can now
# convert to a Table.
# Create a Table object
from ...table import Table
table = Table(np.array(input))
# Read the meta-data from the file
table.meta.update(input.attrs)
return table
[docs]def write_table_hdf5(table, output, path=None, compression=False,
append=False, overwrite=False):
"""
Write a Table object to an HDF5 file
This requires `h5py <http://alfven.org/wp/hdf5-for-python/>`_ to be
installed.
Parameters
----------
output : str or `h5py.highlevel.File` or `h5py.highlevel.Group`
If a string, the filename to write the table to. If an h5py object,
either the file or the group object to write the table to.
compression : bool or str or int
Whether to compress the table inside the HDF5 file. If set to `True`,
``'gzip'`` compression is used. If a string is specified, it should be
one of ``'gzip'``, ``'szip'``, or ``'lzf'``. If an integer is
specified (in the range 0-9), ``'gzip'`` compression is used, and the
integer denotes the compression level.
path : str
The path to which to write the table inside the HDF5 file.
This should be relative to the input file or group.
append : bool
Whether to append the table to an existing HDF5 file.
overwrite : bool
Whether to overwrite any existing file without warning.
"""
try:
import h5py
except ImportError:
raise Exception("h5py is required to read and write HDF5 files")
if path is None:
raise ValueError("table path should be set via the path= argument")
elif path.endswith('/'):
raise ValueError("table path should end with table name, not /")
if '/' in path:
group, name = path.rsplit('/', 1)
else:
group, name = None, path
if isinstance(output, (h5py.highlevel.File, h5py.highlevel.Group)):
if group:
try:
output_group = output[group]
except (KeyError, ValueError):
output_group = output.create_group(group)
else:
output_group = output
elif isinstance(output, basestring):
if os.path.exists(output) and not append:
if overwrite:
os.remove(output)
else:
raise IOError("File exists: {0}".format(output))
# Open the file for appending or writing
f = h5py.File(output, 'a' if append else 'w')
# Recursively call the write function
try:
return write_table_hdf5(table, f, path=path,
compression=compression, append=append,
overwrite=overwrite)
finally:
f.close()
else:
raise TypeError('output should be a string or an h5py File or Group object')
# Check whether table already exists
if name in output_group:
raise IOError("Table {0} already exists".format(path))
# Write the table to the file
if compression:
if compression is True:
compression = 'gzip'
dset = output_group.create_dataset(name, data=table._data, compression=compression)
else:
dset = output_group.create_dataset(name, data=table._data)
# Write the meta-data to the file
for key in table.meta:
val = table.meta[key]
try:
dset.attrs[key] = val
except TypeError:
warnings.warn("Attribute `{0}` of type {1} cannot be written to "
"HDF5 files - skipping".format(key, type(val)), AstropyUserWarning)


Binding lists are generated by the mk tools (i.e., mkapp and mksys) and are installed into the "system" configuration tree by the installer. They are in the "system" tree to keep them protected from sandboxed applications.
Bindings between clients and servers are stored under the client's configuration. If the client is an application, the bindings are stored under the application's configuration in the "system" tree. If the client is a non-application user, the bindings are stored under the "/users/bindings" branch of the "system" tree.
system:/ apps/ <app name>/ bindings/ <client interface name> app <string> user <string> interface <string> users/ <user name>/ bindings/ <client interface name> app <string> user <string> interface <string>
Each <client interface name>
corresponds to an IPC interface required by a component (listed in the api:
subsection of a requires:
section in the component's Component.cdef
file).
Either app
or user
must exist, but never both.
The app
is the name of the application that will run the server on the target.
The user
is the name of the user account that will run the server on the target.
The interface
name corresponds to the server IPC interface name.
load
command that can be used to update the Service Directory with the latest binding configuration from the configuration tree.Copyright (C) Sierra Wireless Inc. Use of this work is subject to license.


Atlanta House Buyers buys houses from people in situations just like yours and solve their real estate problems.
We know that trying to sell your own home can be a major hassle! There are Real Estate Contracts that can tie you to commissions, even if you sell the house without the help of an Agent. Listing a house in the newspaper and other publications can be terribly expensive, even if for only a few days.
 If you have never tried to sell a home, you may not understand all that's involved: the commissions, the loan approval time, the waiting for agent to show your house, the ads that never seem to make the phone ring-- the list goes on. Having strangers walking through every room trying to find the smallest thing to bring down your commission inflated asking price.... in fact, it can easily turn into a horrible experience.
I do know what homeowners go through when they try to sell their home. You may still be in the "thinking about it" stage.


I'm Gabriel Eugenio Chavez Portillo I'm from El Salvador, I'm 19 years old and I like to play videogames with my friends and talk with them, I have the opportunity to travel to a few countries basically north America and part of Central America so that one of my hobbies I love the travels because I think that all the countries are beautiful and you can see it through your eyes.
That's me with and my uncle in new york
In the music area, I like a lot of music basically but my favourite style is Pop, Trap and Latin Trap, Some of my top music artist are Bad Bunny, Paulo Londra and Nicki Nicole (They're Latin American singers).
In movies I like the superheroes movies, fiction and documentaries, some of my top movies and documentaries are Infinity War, Interstellar and My octopus teacher.
In series I like the fiction, suspense and comedy, some of my top series are Friends, Umbrella Academy and Ragnarok.

She is one of my favourite animals she is two years and 9 months old, she is always talking also likes to stay with me on my shoulder.

He is a Catalan shepherd he is a big ball of hair I put him the name oso which means bear in spanish because is always sleeping and likes hugs.


--- layout: target-layout subject: Beep Beep!  --- Your order was picked up on Sat, Mar 6 at University Parkway Total paid $33.15 Scan for in-store returns: 2-1065-3991-0654-7446-1 VCD: 750-259-044 Any issues with your order? Save time and fix issues like missing or incorrect items online. This order will be eligible for online support tomorrow. Fix an issue Items picked up Tresemme Medium to Dark Tones Brunette Clean Dry Shampoo - 7.3 oz Qty: 1 Men's 8.5" Fiery Swim Board Trunks - Goodfellow & Co™ Cayenne Red 42 Qty: 1 Visit order details
2-1065-3991-0654-7446-1
VCD: 750-259-044
Save time and fix issues like missing or incorrect items online. This order will be eligible for online support tomorrow.
Qty: 1


Took the hit in one lungful while lying in bed. Blue flame was used to ignite the flaky 10X Salvia divinorum extract in my jade spirit pipe reserved for this use.
'...from here to there, oh okay... heheheh can you do that thing with my eyes again?'
Took some time here trying to figure out how my eyes were being exercised as they were, because it felt so good and I remembered the feeling from prior trips. The best I could tell, was that when I closed my eyes they were flitting around as they do during REM sleep and the feeling of my eyelashes brushing my face felt funny. During the experience, I thought my eyes were getting a good cleaning.
Random thoughts overflowed from the workday into my Salvia trip and colored the experience with what seemed to be rather pedstrian concepts, like coworker relations and customer satisfaction. I got the idea that I could formulate certain questions in my mind and receive an answer from the Salvia. I think this effect has the been most useful benefit Salvia has offered me so far. Relevant to my workday and to the topics I was looking over during the beginning of the trip:
'I wonder if she will remain upset?'
The answer came without hesitation: 'only while you continue to be upset with her.'
I felt the answer as much as I 'heard' it, and what's more... I understood it.
'Do I have time to ask more questions?'
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


1) Getty Museum Research https://www.getty.edu/research/tools/ , Accessibility (79), SEO (82)
This project is to test and improve the web-accessibility of the museum websites.
I started research about the museum websites and narrowed down into five museums for accessibility/seo audit. I used a Chrome Development tool named lighthouse to diagnose the accessibility and SEO score of those websites.
1) Getty Museum Research https://www.getty.edu/research/tools/ , Accessibility (79), SEO (82)
2) Coca-Cola Museum, https://www.worldofcoca-cola.com/ , Accessibility (82), SEO (83)
Snoopy Museum, https://www.schulzmuseum.org/timeline/ , Accessibility (87), SEO (92)
4) Tustin history, https://www.tustinhistory.com/articles/hewes-home.htm/ , Accessibility (68), SEO (70)
5) Pez Museum, https://us.pez.com/pages/hours-and-location , Accessibility (89), SEO (92)
some analysis, especiailly what kinds of codes looks influential on the seo score and accessibity
The getty research tool site was chosen for the project. List the multiple reasons for the musuem of your choice. Here are the process I develop and test to improve its accessibililty and seo.
semantic structure image
Describe what you did to ensure the semantic html and provide the link to assignment02.
color contrast image
Describe what you did for color-variation (with screenshots) and provide the links to darkmode, lightmode, and monochomatic version.
color contrast image
Describe what you did to test keyboard accessibility and tab-order. Provide the link to assignment04.
color contrast image
Describe what you did to support assistive technologies (or screen readers). Provide the link to assignment05.
Write a brief reflection what you learned about evaluation and development with web-coding to improve web accessibility and SEO. Provide a summary of before (original site) and after (your mockup site) SEO and web accessibility audit report. You may need to provide a report or specifics with the evidence you have improved the work. State what you would want to work more (or any remaining questions) for the future work.


This is me just showing that I can use rows and Columns.
So, I'm really just a programming student with a graudation date of May 2020.
This website is just a place where I can showcase my skills that I've learned
on my own and in the classroom. Hoping to be a software engieer/programmer/developer, etc.
Also looking to use what skills I learn for the greater good one way or another.
Oh, and React is next up on the list of skills to learn, just fy
Looks like I have a decent grasp on it.


---
layout: post
title: EncFS and libpam-encfs on Ubuntu 6.10 Edgy
date: '2007-03-25T00:31:00.000+01:00'
author: Steven Van Acker
tags:
modified_time: '2008-01-18T10:44:07.457+01:00'
blogger_id: tag:blogger.com,1999:blog-5513234137363262204.post-8514033585986167782
blogger_orig_url: http://www.singularity.be/2007/03/encfs-and-libpam-encfs-on-ubuntu-610.html
---
I finished the Using EncFS with libpam-encfs on Ubuntu 6.10 (Edgy) walkthrough!
And since I'm not happy with the amount of google-hits I get on it, I thought I'd link it from here ;)


You are currently logged out
Hello {{ Svcs.Member.member_name }}
You are currently logged in as [{{ Svcs.Member.member_name }}]
| Signup Time | {{ Svcs.Member.member_data.signup_time | date : 'medium' }} |
|---|---|
| Login Time | {{ Svcs.Member.member_data.login_time | date : 'medium' }} |
| Member Name | {{ Svcs.Member.member_name }} |
| Email Address | {{ Svcs.Member.member_email }} |
| Your Files |
|


domestic | fire | annex 2.C | vulnerability of roof coverings | 2010
annex
2.C
2.C.0 Introduction
This annex provides guidance on the vulnerability of roof coverings and is
concerned with the performance of roofs when exposed to fire from
neighbouring
buildings
.
Commission Decision 2005/823/EC amending Decision 2001/671/EC
establishing a classification system for the external fire performance of roofs
and roof coverings allows the classification of performance by either:
a. BS 476: Part 3: 2004 (National Test), External fire exposure roof tests; or
b. BS EN 13501-5: 2005 (European Test), Fire classification of construction
products and building elements, Part 5-Classification using test data from
external fire exposure to roof tests.
2.C.0
—
2.C.0
domestic | fire | annex 2.C | vulnerability of roof coverings | 2010
2.C.1 Vulnerability of roof coverings
The level of vulnerability is established from the guidance to standard 2.1 to
2.15. Reference throughout this document to a low, medium or high
vulnerability, will be satisfied by following the guidance in the tables. The
British Standard classification does not automatically equate with the
equivalent classifications in the European standards column therefore,
products cannot typically assume a European class, unless they have been
tested accordingly. The designer is free to choose materials or products,
which satisfy either the British Standard Tests or the Harmonised European
Tests.
Transitional period
British and European fire tests will co-exist in use until the British Standard
classifications are withdrawn.
2.C.2 British Standards and associated specifications
The national test for roof coverings is BS 476: Part 3: 2004 which measures
the capability of a roof to resist penetration from fire and flame spread when
the external surface is exposed to radiation and flames.
BS 476: Part 3: 2004 sets out a classification system based on external
penetration and flame spread as set out in the following table. The first letter
of the designation indicates fire penetration performance i.e. the time at
which any glowing or flaming [other than that from the gas pilot flame]
appears on the underside of the specimen. The second letter of the
designation indicates flame spread performance. The addition of the suffix ‘X’
indicates dripping from the underside of the specimen, any mechanical failure
or development of holes in the specimen. The angle of the specimen in the
test is designated by the prefix ’S’ [slope] or ‘F’ [flat].
Penetration
Flame spread
A
Those specimens which have
not been penetrated within
60 minutes
A
Those specimens on which there
is no spread of flame
B
Those specimens which are
penetrated in not less than
30 minutes
B
Those specimens on which there
is not more than 525 mm spread
of flame
C
Those specimens which are
penetrated in less than
30 minutes
C
Those specimens on which there
is more than 525 mm spread of
flame
D
Those specimens which are
penetrated in the preliminary
test
D
Those specimens which continue
to burn for more than 5 minutes
after the withdrawal of the test
flame or spread of flame more
than 375 mm across the region
of burning in the preliminary test
2.C.1
—
2.C.2
domestic | fire | annex 2.C | vulnerability of roof coverings | 2010
2.C.3 Harmonised European Standards
The European test method has been published as DD ENV 1187: 2002, ‘Test
methods for external fire exposure to roofs’, which specifies four methods for
determining the performance of roofs to external fire exposure:
•
Test 1 : with burning brands;
•
Test 2 : with burning brands and wind;
•
Test 3 : with burning brands, wind and supplementary radiant heat;
•
Test 4 : two stage test method incorporating burning brands, wind and
supplementary radiant heat.
Only test method 4 evaluates penetrability in a satisfactory way to satisfy the
fire performance requirements in the United Kingdom. For this reason, (t4)
has been added to the European test designations to add clarity.
The performance criteria in terms of vulnerability to external fire exposure can
be satisfied where the roof covering follows the guidance in the following
table. The classification methodology is contained in BS EN 13501-5: 2005.
Classification for roofs / roof coverings exposed to external fire
Broof (t4) a. No penetration of roof system within 60 minutes
b. In preliminary test, after withdrawal of the test flame,
specimens burn for less than 5 minutes
c. In preliminary test, flame spread less than 0.38 m across
region of burning
Croof (t4) a. No penetration of roof system within 30 minutes
b. In preliminary test, after withdrawal of the test flame,
specimens burn for less than 5 minutes
c. In preliminary test, flame spread less than 0.38 m across
region of burning
Droof (t4) a. Roof system is penetrated within 30 minutes but is not
penetrated in the preliminary test
b. In preliminary test, after withdrawal of the test flame,
specimens burn for less than 5 minutes
c. In preliminary test, flame spread less than 0.38 m across
region of burning
Eroof (t4) a. Roof system is penetrated within 30 minutes but is not
penetrated in the preliminary test
b. Flame spread is not controlled
Froof (t4) c. No performance determined
2.C.3
—
2.C.3
domestic | fire | annex 2.C | vulnerability of roof coverings | 2010
Vulnerability of roof coverings
Column 1
Column 2
Column 3
Vulnerability
British Standards
European Standards
Low
a) designation AA, AB or AC when tested along with the
substrate in accordance with BS 476: Part 3: 2004; or
The material has achieved
a classification of Broof(t4)
in accordance with
BS EN 13501-5: 2005
when tested to
DD ENV 1187: 2002 + A1:
2005, test4.
b) glass at least 4 mm thick; or
c) a roof covering or rooflight of plastics materials which
is in an open canopy or over a substantially open area
such as a loading bay which is a single-skin
polycarbonate sheet not more than 3 mm thick or
multi-skin polycarbonate sheet, or a thermoplastic
material (see clause 2.5.4): a specimen of which when
tested in accordance with Method 508A in
BS 2782: 1970 (1974), performs so that the test flame
does not reach the second mark within 2 minutes, the
specimen thickness to be more than 1.5 mm and not
more than 3 mm; or
d) a thermoplastic sheet with a low or medium risk (see
table to annex 2.C) or a rigid solid PVC (uPVC), or a
polycarbonate rigid solid sheet at least 3 mm thick, or a
multiskin polycarbonate sheet at least 10 mm thick
overall.
Medium
a) designation BA, BB, BC, CA, CB or CC when tested
along with the substrate in accordance with BS 476: Part
3: 2004; or
The material has achieved
a classification of Croof(t4)
and Droof(t4) in
accordance with
BS EN 13501-5: 2005
when tested to
DD ENV 1187: 2002 + A1:
2005, test4.
b) a roof covering or rooflight of plastics materials which
is a single-skin polycarbonate sheet not more than 3 mm
thick or multi-skin polycarbonate sheet, or thermoplastic
material, a specimen of which when tested in accordance
with Method 508A in BS 2782: 1970 (1974), performs so
that the test flame does not reach the second mark within
2 minutes, the specimen thickness to more than 1.5 mm
and not more than 3 mm.
High
Any designation other than low or medium vulnerability,
including for example, timber shingles or thatch.
The material has achieved
a classification of Eroof(t4)
and Froof(t4) in
accordance with
BS EN 13501-5: 2005
when tested to
DD ENV 1187: 2002 + A1:
2005, test4.
2.C.3
—
2.C.3


Public key and mnemonic
Your wallet address
If someone wants to share something with you: give out your wallet-address:
vpn_key
{{eth.getAddress()}}
(click to copy to clipboard)
Mnemonic
If you want to use sharu on a different computer you need the mnemonic to restore your account there. For security
reasons you need to re-enter your password here to retrieve the mnemonic:
0)">
Your mnemonic
{{mnemonic}}


Bus Mall Focus Group
Home
Products
About
Contact
Select an image to vote
Shark Attack Sleeper
BOOTSAH!!
Cthulhu Dawn


A Syberia engine defines the core re-usable structural unit across different Syberia projects. In the same way that Rails engines provide a modular structure for http://rubyonrails.org/ projects, Syberia engines serve as the re-usable rockbed upon which to construct projects that contain similar components.
syberia_engine(filepath = getwd(), ..., root. = TRUE) syberia_project(filepath = getwd(), ..., root. = TRUE)
| filepath | character. The root directory of the engine.
If this directory does not define a (relative) |
|---|---|
| ... | Additional arguments used internally. |
| root. | logical. Whether or not this is a root-level engine,
by default |
The director
object responsible for
managing the engine.
A Syberia engine is managed by a director
object.
This object ensures that the engine cannot access resources outside of
its domain, and allows insularity from other engines and the top-level
project from which the engine will be used.
The syberia package will maintain an internal cache of engines.
Therefore, calling syberia_engine
twice will retrieve the
cached object. This cache is maintained in the .syberia_env
environment object in the syberia package namespace.


WITNESS LIST Criminal Justice Committee May 15, 1997-1:30P HB 195 Registering, but not testifying: For: Holtermann, John W. (TX Silver Haired Leg.), San Marcos HB 844 For: Mitchell, Charles (self), San Augustine HB 3278 Registering, but not testifying: For: Komandosky, Lt. Col. Ed (TX National Guard), Austin HB 3588 Registering, but not testifying: For: Mendez, Mark (Tarrant Co. Comm. Court), Ft. Worth


MY STORE
Admin
Error ({{data.error.status}}). The product data was not loaded.
Click here to try again


Why are you disquieted within me?
HJpe in God; for I will yet praise him,
who is my help and my God.


$ git fetch $ git checkout cow
COW fork() creates just a pagetable for the child, with PTEs for user memory pointing to the parent's physical pages. COW fork() marks all the user PTEs in both parent and child as not writable. When either process tries to write one of these COW pages, the CPU will force a page fault. The kernel page-fault handler detects this case, allocates a page of physical memory for the faulting process, copies the original page into the new page, and modifies the relevant PTE in the faulting process to refer to the new page, this time with the PTE marked writeable. When the page fault handler returns, the user process will be able to write its copy of the page.
COW fork() makes freeing of the physical pages that implement user memory a little trickier. A given physical page may be referred to by multiple processes' page tables, and should be freed only when the last reference disappears.
$ cowtest simple: fork() failed $The "simple" test allocates more than half of available physical memory, and then fork()s. The fork fails because there is not enough free physical memory to give the child a complete copy of the parent.
When you are done, your kernel should be able to run both cowtest and usertests. That is:
$ cowtest simple: ok simple: ok three: zombie! ok three: zombie! ok three: zombie! ok file: ok ALL COW TESTS PASSED $ usertests ... ALL TESTS PASSED $
Here's one reasonable plan of attack. Modify uvmcopy() to map the parent's physical pages into the child, instead of allocating new pages, and clear PTE_W in the PTEs of both child and parent. Modify usertrap() to recognize page faults. When a page-fault occurs on a COW page, allocate a new page with kalloc(), copy the old page to the new page, and install the new page in the PTE with PTE_W set. Next, ensure that each physical page is freed when the last PTE reference to it goes away (but not before!), perhaps by implementing reference counts in kalloc.c. Finally, modify copyout() to use the same scheme as page faults when it encounters a COW page.
It may be useful to have a way to record, for each PTE, whether it is a COW mapping. You can use the RSW (reserved for software) bits in the RISC-V PTE for this.
usertests explores more situations than cowtest, so don't forget to check that all tests pass for both.
Some helpful macros and definitions for page table flags are at the end of the file kernel/riscv.h.
This completes the lab. Commit your changes and type make handin in the lab directory to hand in your lab.


ID: 700
Email<EMAIL_ADDRESS>Office number: 800
He loves creating a memorable work enviroment
Engineer
ID: 899
Email<EMAIL_ADDRESS>GitHub:
He is not afraid to take on the big dogs.
Intern
ID: 500
Email<EMAIL_ADDRESS>School: Harvard
We love this guy!
Employee
ID: 300
Email<EMAIL_ADDRESS>She always right


#include <irrXML.h>
Public Member Functions | |
| virtual | ~IFileReadCallBack () |
| virtual destructor | |
| virtual int | read (void *buffer, int sizeToRead)=0 |
| Reads an amount of bytes from the file. | |
| virtual int | getSize ()=0 |
| Returns size of file in bytes. |
With this, it is possible to make the xml parser read in other things than just files. The Irrlicht engine is using this for example to read xml from compressed .zip files. To make the parser read in any other data, derive a class from this interface, implement the two methods to read your data and give a pointer to an instance of your implementation when calling createIrrXMLReader(), createIrrXMLReaderUTF16() or createIrrXMLReaderUTF32()
Definition at line 70 of file irrXML.h.
| virtual irr::io::IFileReadCallBack::~IFileReadCallBack | ( | ) | [inline, virtual] |
| virtual int irr::io::IFileReadCallBack::getSize | ( | ) | [pure virtual] |
| virtual int irr::io::IFileReadCallBack::read | ( | void * | buffer, | |
| int | sizeToRead | |||
| ) | [pure virtual] |
Reads an amount of bytes from the file.
| buffer,: | Pointer to buffer where to read bytes will be written to. | |
| sizeToRead,: | Amount of bytes to read from the file. |
Implemented in irr::io::CFileReadCallBack.


Raimond Reichert
<EMAIL_ADDRESS>Samuel Zürcher
<EMAIL_ADDRESS>Raimond Reichert, Samuel Zürcher, Ergon Informatik AG
The rate of innovation in the JavaScript space is still incredible. For a while, it seemed that Angular would emerge as a winner in the web application frontend wars. Now, with Meteor, there is a new contender, a full-stack development framework which promises "to allow you to build advanced apps quickly, with a small team – allowing even individuals to achieve things that used to be possible only at large companies like Google and Facebook."
We wanted to gain some experience with Meteor with a very small project (approx. 20d, two people) to form our own opinion on these promises. We were quite impressed, as our estimates of what we would be able to build were way off: We developed roughly 50% more functionality than we had estimated. Meteor seemed easy to learn, and we very quickly felt very productive with Meteor.
In this presentation, we give a short overview on Meteor (with its Distributed Data Protocol, Latency Compensation, and Reactivity) and its components for rendering (Blaze) and testing (Velocity) as well as its package system (atmosphere.js). In a "slide coding" session, we implement a "lessons learned" feature of our demo application, Retro42 (retro42.herokuapp.com) as a showcase for coding with Meteor.
Raimond Reichert, Samuel Zürcher, Ergon Informatik AG
Our motivation for building Retro42
Start from an existing questionnaire template...
... or create a questionnaire from scratch.
Define your schedule for answering your questionnaire.
Retro42 will send you reminder mails according to the schedule
Submit answers to your questionnaire
Review all your answers to a questionnaire
Review your answers to a textual question
Review your answers to a numeric question
Review the percentage of positive answers to a yes/no question
Review a yes/no answers on a calendar
Invite others to participate on a questionnaire
Review a shared questionnaire and its participants
Review your group's questionnaire passes
Review all answers in a group questionnaire pass
Review all answers to a numeric question
Review all answers to a yes/no question
Why did we choose Meteor?
So many web and mobile app development options, yet still no clear winner emerges... making each option a risk with regards to long-term maintainability.
We chose Meteor because it implements an approach which is quite different from what we've gotten used to.
Why did we choose Meteor?
Why did we choose Meteor?
What is Meteor?
meteor add <package name>
meteor run
meteor reset
What is Meteor?
meteor add coffeescript
adds CoffeeScript support to your project – that's itsee quora.com/Node-js/Why-does-Meteor-use-its-own-package-system-rather-than-NPM
What is Meteor?
see atmospherejs.com
What is Meteor?
The same database API works on both client and server.
The API is compatible with the Mongo database API.
# common code on client and server declares a DDP-managed mongo collection
Messages = new Mongo.Collection "messages"
# return array of my messages (here, in client code)
myMessages = Messages.find({userId: Meteor.userId()}).fetch()
# create a new message
Messages.insert {text: "Hello, world!"}
# mark my first message as "important"
Messages.update myMessages[0]._id, {$set: {important: true}}
see docs.meteor.com/#/full/mongo_collection
What is Meteor?
What is Meteor?
In its current release, Minimongo has some limitations:
All of these will be addressed in a future release.
What is Meteor?
var spaceship = {
_temperature: 0, _listeners: [],
getTemperature: function() {
return this._temperature;
},
setTemperature: function(value) {
this._temperature = value;
this.changed();
},
// to be continued
};
from stephenwalther.com/archive/2014/12/05/dont-do-react-understanding-meteor-reactive-programming
What is Meteor?
var spaceship = { // code from previous slide
changed: function() {
for (var i=0;i< this._listeners.length;i++) {
this._listeners[i]();
}
},
onChanged: function(func) {
this._listeners.push(func);
}
};
// observer updates dashboard when temperature changes
spaceship.onChanged(function() {
var temp = spaceship.getTemperature();
gauge.setValue(temp);
});
from stephenwalther.com/archive/2014/12/05/dont-do-react-understanding-meteor-reactive-programming
What is Meteor?
var spaceship = {
_temperature: 0,
_temperatureDepend: new Tracker.Dependency,
getTemperature: function() {
this._temperatureDepend.depend();
return this._temperature;
},
setTemperature: function(value) {
this._temperature = value;
this._temperatureDepend.changed();
}
};
from stephenwalther.com/archive/2014/12/05/dont-do-react-understanding-meteor-reactive-programming
What is Meteor?
// Tracker updates dashboard when temperature changes
Tracker.autorun(function() {
var temp = spaceship.getTemperature();
gauge.setValue(temp);
});
The function passed to Tracker.autorun() is rerun automatically whenever any of its dependencies change.
from stephenwalther.com/archive/2014/12/05/dont-do-react-understanding-meteor-reactive-programming
What is Meteor?
You rarely work with Tracker Dependency directly. Instead, you work with Meteor's reactive data sources such as:
from stephenwalther.com/archive/2014/12/05/dont-do-react-understanding-meteor-reactive-programming
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
What is Meteor?
Spacebars is simply HTML, with the addition of three things:
What is Meteor?
In this example, url
and title
come from a post
object, whereas domain
is a call to a template helper function:
{{title}}{{domain}}
Template.postItem.helpers
domain: () ->
a = _createLink this.url
a.hostname
What is Meteor?
Blaze is reactive: The template will update automatically, with no additional work on your part. This works even if the template runs arbitrary JavaScript code to compute its data.
Blaze's simplicity is made possible by Tracker, an extremely lightweight (one kb) system for transparent reactivity.
By wiring all of this up for you, Blaze removes an enormous amount of boilerplate from your app, and allows you to say what you want once without repeating yourself.
from meteor.com/blaze
What is Meteor?
Show me some code!
Let user add lessons learned to a questionnaire:
Show me some code!
Display lessons learned of a questionnaire:
Show me some code!
{{> _questionnaireTitleDescription}}
{{> _questionnaireButtons}}
{{> lessonsLearnedTemplate questionnaireId=_id}}
lessonsLearnedTemplate
in the questionnairePasses
template._id
as questionnaireId
.Show me some code!
<template name="lessonsLearnedTemplate">

{{_ 'lessonsLearnedTemplate.title'}}

{{#if lessonsLearned}}

{{#each lessonsLearned}}
<
{{/each}}

{{/if}}
</template>
lessonsLearnedTemplate
is the key which we will use in our CoffeeScript code.{{_ 'key'}}
is i18n with Meteor package tap:i18n.Show me some code!
{{#each lessonsLearned}}

{{createdAtAbsolute}} {{createdAtRelative}}
{{text}}

{{_ 'lessonsLearnedTemplate.delete'}}

{{/each}}
lessonsLearned, createdAtAbsolute
.text
.{{#each lessonsLearned}}
creates a new this
scope for each document in the collection.Show me some code!
Template.lessonsLearnedTemplate.helpers
lessonsLearned: () ->
LessonsLearned.find({questionnaireId: this.questionnaireId},
{sort: {createdAt: -1}}).fetch()
createdAtAbsolute: () ->
moment(this.createdAt).format('YYYY-MM-DD HH:mm')
createdAtRelative: () ->
moment(this.createdAt).fromNow()
this.questionnaireId
.LessonsLearned
collection.this
scope for the helper functions createdAt*
is a lesson learned document.Show me some code!
@LessonsLearned = new Mongo.Collection 'lessons_learned'
LessonsLearned.allow
insert: (userId) ->
userId is Meteor.userId()
remove: (userId, lessonLearned) ->
userId? and (userId is lessonLearned.userId)
new Mongo.Collection 'lessons_learned'
. On the server, this sets up a MongoDB collection called my-collection; on the client, this creates a cache connected to the server collection.Show me some code!
# server-side only code
Meteor.publish 'lessons_learned', (questionnaireId) ->
check questionnaireId, String
LessonsLearned.find(
{questionnaireId: questionnaireId, userId: this.userId},
{sort: {createdAt: -1}}
# server- and client-side code
Router.route '/questionnaires/:_id/passes', {
name: 'questionnairePasses'
waitOn: () -> [
Meteor.subscribe 'questionnaire', this.params._id
Meteor.subscribe 'lessons_learned', this.params._id
Meteor.subscribe 'questionnaire_passes', this.params._id
]
data: () -> Questionnaires.findOne this.params._id
}
Show me some code!
from Discover Meteor
Show me some code!
from Discover Meteor
Show me some code!
from Discover Meteor
Show me some code!
from Discover Meteor
Show me some code!
{{_ 'lessonsLearnedTemplate.title'}}
Template.lessonsLearnedTemplate.events
'submit #addLessonLearned': (event) ->
event.preventDefault()
LessonsLearned.insert
questionnaireId: this.questionnaireId
userId: Meteor.userId()
text: event.target.text.value
event.target.text.value = ''
'click .deleteLessonLearned': () ->
LessonsLearned.remove this._id
Show me some code!
Making our relative time stamps react to language change:
Template.lessonsLearnedTemplate.helpers
createdAtRelative: () ->
share.languageDependency.depend()
# make this computation dependent on a shared dependency
moment(this.createdAt).format('YYYY-MM-DD HH:mm')
# client/startup.coffee
Meteor.startup () ->
share.languageDependency = new Deps.Dependency
# client/templates/header.coffee
Template.header.events
'click .tap-i18n-buttons button': () ->
newLanguage = TAPi18n.getLanguage()
accountsUIBootstrap3.setLanguage newLanguage
moment.locale newLanguage
share.languageDependency.changed()
# forces re-computation of all dependent computations
Show me some code!
We've implemented the "lessons learned" feature without any callbacks! In many cases, Meteor takes care of the asynchronicity and the callbacks necessary to deal with it.
If you need to explicitely call a server-side function, use Meteor.call
. Using a ReactiveVar
, it's easy to update the UI reactively.
In our project, we only used Meteor.call
nine times, some due to Mini-MongoDb limitations (no aggregations).
Show me some code!
_numericAnswersChartVar = new ReactiveVar null
Template.questionnaireQuestionView.helpers
numericAnswersChart: () -> _numericAnswersChartVar.get()
Template.questionnaireQuestionView.onRendered () ->
questionnaire = this.data
Meteor.call 'questionnaireQuestionAnswers', Router.current().params._id,
Router.current().params._questionUuid, (error, result) ->
if error then return share.showErrorMessage error.reason
question = share._question questionnaire
if question.type is 'numeric'
timeSeries = _.map result,
(answer) -> [answer.createdAt.getTime(), parseFloat(answer.value)]
numericChart = _numericChart timeSeries.reverse(), questionnaire
_numericAnswersChartVar.set numericChart # update ReactiveVar
Comparing Meteor vs. MEAN
Meteor = MEAN stack + Socket.IO + grunt/gulp + Cordova + hot code reload + a lot more.
from wiki.dandascalescu.com/essays/meteor_js_vs_the_mean_stack,
see also wiki.dandascalescu.com/essays/why_meteor
Comparing Meteor vs. MEAN
Comparing Meteor vs. MEAN
meteor add accounts-google
, then add {{> loginButtons}}
in your template to show the login UI, and you're done.Comparing Meteor vs. MEAN
Comparing Meteor vs. MEAN
"Week 3: Tasks were being completed faster than ever before. We did struggle occasionally, but we were able to find plenty of documentation and support from our super smart lead developer who we call Google. At the end of one week, we had completed more in Meteor than the entire previous month in .NET."
see info.meteor.com/blog/from-.net-to-meteor-in-30-days (2015-09-09)
More about Meteor
see info.meteor.com/blog/whats-coming-in-meteor-12-and-beyond
More about Meteor
More about Meteor
see discovermeteor.com, guide.meteor.com, and meteor.com
Conclusion
| At schedules intervals, send reminder mails |
| Allow user to schedule his questionnaires |
| When answering questions, show previous answers to the current question |
| Allow yes/no questions |
| For numeric questions, show graph of all answers to this question |
| Show all answers for a selected question |
| Show questions & answers for a selected session |
| Show list of sessions for a selected questionnaire |
| Answer questions for a selected questionnaire |
| Configure questionnaire for current user |
| Show questions (question-text only) for a selected questionnaire |
| Show list of all questionnaires (user-independent) after login |
| Simple application with Google auth |
| Deployment Environment Setup |
| VM Setup including Development Environment |
| Intro page for non-logged in users for-email UI |
| Questionnaire Passes View: percentage answered groups |
| Group Question View groups |
| Group Pass View groups |
| Add group users to questionnaire groups |
| Questionnaire passes: Show some boolean and numeric answers in overview difficult duplicate UI |
| Display questionnaire passes in a table |
| Markdown Support for Text Questions |
| Add demo data to fixture for-email |
| Create questionnaire from scratch |
| Show user notification on missed questionnaire passes |
| Allow user to delete questionnaire (and its passes) |
| Allow user to edit questionnaire |
| Enhance list of sessions for a selected questionnaire with scheduling info |
Meteor has been called "embarrassingly easy-to-learn":
We definitively agree.
Conclusion
Conclusion
What we missed most about Meteor was in-built support for unit and integration tests, client- and server-side.
Also, we would like to see alternatives to the Robot framework for web tests.
Conclusion
Backup Slides
Backup Slides
Comparing Blaze, React Meteor, Angular-Meteor, Angular 2 with Meteor, with "Waldo Finder".
see info.meteor.com/blog/comparing-performance-of-blaze-react-angular-meteor-and-angular-2-with-meteor
Backup Slides
Backup Slides
Backup Slides
Backup Slides
Stefan Hanenberg et al. An empirical study on the impact of static typing on software maintainability. Empirical Software Engineering,
Oct. 2014, Vol. 19, No. 5, pp 1335-1382.
Backup Slides
Isogaba maware: When you are in hurry, take your time


Latest titles and reading ideas for children aged 0-11.
Advice, guidance and stories to share to help tackle some of the challenges of raising a family.
Regular activity sessions and events, including songs, rhymes, stories, playtimes, crafts, clubs, reading groups and Minecraft clubs.
What we stock and how you can use the service to help your child's reading and development.


Topics: concurrency, multicore processors, Common Lisp
Author: Marijn Haverbeke
Date: June 5th 2008
I think that, over the past year, I've read some thirty articles that start with the solemn or anxious announcement that the future of programming will be multicore, and that one way or another, we will have to get used to it. I'll try not to write another one of those. In fact, it appears that multicore processors are also pretty good single-core processors, and most applications are, for the foreseeable future, comfortably single-threaded. And in a lot of cases, they should be. So is there any pressing reason to take notice of this new-fangled hardware?
[I]t looks more or less like the hardware designers have run out of ideas, and that they’re trying to pass the blame for the future demise of Moore’s Law to the software writers by giving us machines that work faster only on a few key benchmarks!
That is from none less than Donald Knuth, in a recent interview. Nonetheless, I have (belatedly, I'll admit) started to get excited about incorporating the kind of 'multi-threading for the sake of multi-threading' that multiple cores encourage into my programs. Why? This might not be a very convincing reason for the serious, result-oriented programmer, but parallel programming, it turns out, is very amusing. Sure, there are dead-lock death-traps, race-conditions, and a general dangerous sense of non-determinism. But there is a logic to all of it, and a working parallel program can be a thing of beauty. That kind of beauty, and the complexity that tends to go with it, is what got me into this business in the first place. (It wasn't my love for hunching over keyboards or a deep dislike of sunlight, in any case.)
This infatuation started ― predictably enough ― with Erlang. Erlang is kind of hip, makes you think about concurrency in a whole new way, and is entirely dissatisfactory as a programming language. I won't go too deeply into that last point, since taking cheap shots at other people's work tends to hurt one's credibility, but the un-polished and limited feel of the language offended my delicate linguistic sensibilities, and prevented me from investing too deeply into it, with the result that I am still (also somewhat grudgingly, perhaps) doing most of my work in Common Lisp.
Common Lisp has no integrated, light-weight, multicore-friendly threads. In fact, in only recently started having widespread support for OS-level threads at all. This support comes, invariably, in the form of shared memory, locks, and semaphores (bordeaux-threads provides a pleasant portable wrapper). While these allow just about any kind of concurrent program to be written, they are fairly tedious and error-prone to work with. CL-MUPROC builds a message-passing system on top of them, which allows a more pleasant programming style. Every CL-MUPROC process is an OS thread though, so you won't want to create thousands of them.
Another approach for getting away from mutexes, one that has been generating a lot of noise recently, is software transactional memory. If that doesn't mean anything to you, I'd recommend watching this video of Simon Peyton Jones explaining the idea. I was surprised to find that there apparently exists a CL-STM (aren't we CLers creative when it comes to naming projects). Seems to have been inactive since early 2007, and as I understand it, STM is rather hard to get right, so I'm not sure I'd risk building something serious on this... but it appears to work. The Clojure people seem to be making good use of STM in any case.
On a related note, SBCL
exports a symbol sb-ext:compare-and-swap
, which can
be used to do small-scale transactional tricks, and is often an
order of magnitude faster than the equivalent locking solution.
Here is a very simple concurrency-safe stack. The macro is a
convenient wrapper that helps use compare-and-swap
in
a 'transactional' way.
(defmacro concurrent-update (place var &body body) `(flet ((action (,var) ,@body)) (let ((prev ,place)) (loop :until (eq (sb-ext:compare-and-swap ,place prev (action prev)) prev) :do (setf prev ,place)) prev))) (defun make-cstack (&rest elements) (cons :stack elements)) (defun push-cstack (element stack) (concurrent-update (cdr stack) elts (cons element elts)) (values)) (defun pop-cstack (stack) (car (concurrent-update (cdr stack) elts (cdr elts))))
Stacks are represented as cons cells, since
compare-and-swap
can only be used on a limited set of
'places' (cars, cdrs, svrefs, symbol-values), and not on things
like instance or struct slots. Writing a queue is only slightly
more complicated. Making popping threads block when there are no
elements available, on the other hand, is decidedly tricky. (I
think I have a working implementation... it is much faster than
the locking variant, but it is so complicated that I'm not
convinced it is correct. If you can recommend any good books or
papers on low-level concurrency techniques, please drop me an e-mail.)
In the book How to Write Parallel Programs, which is old (1992) but still relevant, the authors distinguish three models of concurrency: Message passing (as in Erlang), shared or distributed data structures (as in Java), and 'live' data structures, where computations turn into values after they finish running. These are all fundamentally equivalent, in that a program using one of them can always be transformed to use another, but some programs are much more natural when expressed in the right model. STM, which had not been invented at the time the book was written, would probably qualify as a special case of shared data structures.
One of these models, live data structures, has never been very
popular. This might be related to the fact that they offer none of
the control-flow advantages that the other models have ―
you spawn a process, and then later you can read the value it
produced, but this only buys you something when there is a direct
advantage to computing values in parallel. On single-core
machines, there isn't, but on multicores, this might be a very
pleasant way to speed up some CPU-bound programs. On first seeing
Haskell's par
operator, which implements something
like this, I was duly impressed. You just pass two computations to
a little operator and, under the right circumstances, you get your
results twice as fast.
Now, without further ado, I'd like to present my new library:
PCall (for parallel call). It implements a thread pool and a few
simple operators to get behaviour not unlike that of Haskell's
par
. As a silly example, it can get two seconds worth
of sleep in only a single second!
(time (let ((a (pexec (sleep 1))) (b (pexec (sleep 1)))) (join a) (join b)))
The code behind this is rather humble and simple, but it seems to work well. See the project page for more details and examples.
This kind of 'local parallelism' makes it relatively easy to verify that the tasks are using their data in a safe way ― you typically just make sure that no tasks write to the same location or read anything another task might write.
One issue that keeps coming up with this style of parallelism, an issue that the book I mentioned above also discusses, is finding the right granularity when splitting up tasks. Wrapping up a computation in a function, putting it into a queue, having some thread find it and execute it, and then reading out the results... that is obviously more work than just directly executing the computation. Thus, if the computation is small enough, you are making your program slower by parallelising it.
The solution suggested by the book is to provide a 'granularity knob' ― some setting that controls the size of the computation chunks that get delegated off to other processes. When mapping some function over a list, you could for example provide a way to control the amount of elements each task takes care of, and vary that based on the amount of available processors and the amount of computation the given function requires. In some cases, the granularity adjustment could be done automatically by profiling the running code. I guess that is usually more trouble than it is worth, though.
There are also situations where different environments call for completely different approaches. Having a central lock on something works well when there are ten threads occasionally accessing it, but becomes a bottleneck when there are a thousand. Optimistic transactions that fail when another thread interferes with their data have the same problem: They fall apart when there are too many processes. On the other hand, complex schemes that minimise the amount of conflict between threads also carry an overhead, and are often counterproductive when there are only a handful of threads. This is a less pleasant side of concurrent programming: There often is no right solution. In sequential programs, you can weight program complexity against efficiency, and often feel you've hit some sweet spot.
Despite of this, and the claims by various people that threading is 'just too hard', I rather suspect we'll be able to work it out. As in other complicated fields, it is mostly a matter of finding better abstractions. I hope PCall can provide an abstraction suitable for some problems (though, at this point, I'm not even a hundred percent convinced there are no race conditions left in the library... do help me test it).


Home
reading
Project 3
Communication
Project brief
In this project, I was trying to get the data from my raindrop sensor and visualize it on the website.
Video
How it worked
load the js code so I can receive data
visualize the ball


|
Memory-mapped files stream
Provide read-write access to memory-mapped files on Windows and POSIX systems.
|
fmstream provides an interface to read/write data from/to memory-mapped files as input/output streams. More...
#include <fmstream.h>
Public Member Functions | |
| fmstream () | |
| Construct object. | |
| fmstream (const char *path_name, std::streamsize max_length=0, std::streamoff offset=0) | |
| Construct object and open or create a file. | |
| virtual | ~fmstream () |
| Destructs the fmstream object. | |
| filemappingbuf * | rdbuf () const |
| Get the associated filemappingbuf object. | |
| bool | is_open () const |
| Check if a file is open. | |
| void | open (const char *path_name, std::streamsize max_length=0, std::streamoff offset=0) |
| Open file. | |
| void | close () |
| Close file. | |
| const void * | ptellg () |
| Get position of the get pointer. | |
| void * | ptellp () |
| Get position of the put pointer. | |
| std::istream & | pseekg (const void *ptr) |
| Sets the position of the get pointer. | |
| std::ostream & | pseekp (void *ptr) |
| Sets the position of the put pointer. | |
| const void * | data () const |
| Get the read-only base address of the mapping. | |
| void * | data () |
| Get the base address of the mapping. | |
| std::streamsize | size () const |
| Get the maximum byte length of the mapping. | |
C++11 | |
The following methods requires some features introduced by the latest revision of the C++ standard (2011). Older compilers may not support it. | |
| fmstream (fmstream &&rhs_stream) | |
| Move constructor (requires C++11). | |
| fmstream & | operator= (fmstream &&rhs_stream) |
| Move assignment (requires C++11). | |
| void | swap (fmstream &stream) |
| Swap internals (requires C++11). | |
fmstream provides an interface to read/write data from/to memory-mapped files as input/output streams.
The objects of this class maintain internally a pointer to a filemappingbuf object that can be obtained by calling member rdbuf. The file to be associated with the stream can be specified either as a parameter in the constructor or by calling member open. After all necessary operations on a file have been performed, it can be closed (or disassociated) by calling member close. Once closed, the same file stream object may be used to open another file. The member function is_open can be used to determine whether the stream object is currently associated with a file. fmstream can be used in place of std::fstream.
| fmstream::fmstream | ( | ) |
Construct object.
Constructs an object of the fstream class. This implies the initialization of the associated filemappingbuf object and the call to the constructor of its base class with the filemappingbuf object as parameter.
|
explicit |
Construct object and open or create a file.
Constructs an object of the fstream class. This implies the initialization of the associated filemappingbuf object and the call to the constructor of its base class with the filemappingbuf object as parameter. The stream is associated with a physical file as if a call to the member function open with the same parameters was made. If the constructor is not successful in opening the file, the object is still created although no file is associated to the stream buffer and the stream's failbit is set (which can be checked with inherited member fail).
| path_name | C-string contains the name of the file to be opened or created. |
| max_length | Maximum length of the file mapping. If this parameter are 0, the maximum length of the file mapping object is equal to the current size of the file. |
| offset | File offset where the mapping begins. They must also match the memory allocation granularity of the system. That is, the offset must be a multiple of the allocation granularity. To obtain the offset granularity of the system, use filemapping::offset_granularity(). |
| fmstream::fmstream | ( | fmstream && | rhs_stream | ) |
Move constructor (requires C++11).
Acquires the contents of rhs_stream, by move-assigning its members and base classes.
| rhs_stream | File stream to move. rhs_stream becomes of invalid state after the operation. |
| void fmstream::close | ( | ) |
Close file.
Closes the file currently associated with the object and disassociates it. The function fails if no file is currently open (associated) with this object. On failure, the failbit flag is set (which can be checked with member fail), and depending on the value set with exceptions an exception may be thrown.
| const void * fmstream::data | ( | ) | const |
Get the read-only base address of the mapping.
The function fails if no file is currently open (associated) with this object.
| void * fmstream::data | ( | ) |
Get the base address of the mapping.
The function fails if no file is currently open (associated) with this object.
| bool fmstream::is_open | ( | ) | const |
Check if a file is open.
Returns true if the stream is currently associated with a file, and false otherwise. The stream is associated with a file if either a previous call to member open succeeded or if the object was successfully constructed using the parameterized constructor, and close has not been called since.
| void fmstream::open | ( | const char * | path_name, |
| std::streamsize | max_length = 0 , |
||
| std::streamoff | offset = 0 |
||
| ) |
Open file.
Opens a file whose name is path_name, associating its content with the stream object to perform input/output operations on it. The operations allowed and some operating details depend on parameter mode. If the object already has a file associated (open), this function fails. If the file do not exist, the file is created with the 'offset + max_length' size. If the size of the opened file is less than 'offset + max_length', the file growing. If the size of the opened file is greater than 'offset + max_length', the file is not truncated. An attempt to map a file with a length of 0 fails. On failure, the failbit flag is set (which can be checked with member fail), and depending on the value set with exceptions an exception may be thrown.
| path_name | C-string contains the name of the file to be opened. |
| max_length | Maximum length of the file mapping. If this parameter are 0, the maximum length of the file mapping object is equal to the current size of the file. |
| offset | File offset where the mapping begins. They must also match the memory allocation granularity of the system. That is, the offset must be a multiple of the allocation granularity. To obtain the offset granularity of the system, use filemapping::offset_granularity(). |
Move assignment (requires C++11).
Closes the source stream (as if member close was called), and then acquires the contents of rhs_stream.
| rhs_stream | File stream to move. rhs_stream becomes of invalid state after the operation. |
| std::istream & fmstream::pseekg | ( | const void * | ptr | ) |
Sets the position of the get pointer.
The get pointer determines the next location to be read in the source associated to the stream. The function fails if no file is currently open (associated) with this object. On failure, the failbit flag is set (which can be checked with member fail), and depending on the value set with exceptions an exception may be thrown.
| ptr | New absolute position for the input pointer. |
| std::ostream & fmstream::pseekp | ( | void * | ptr | ) |
Sets the position of the put pointer.
The put pointer determines the location in the output sequence where the next output operation is going to take place. The function fails if no file is currently open (associated) with this object. On failure, the failbit flag is set (which can be checked with member fail), and depending on the value set with exceptions an exception may be thrown.
| ptr | New absolute position for the output pointer. |
| const void * fmstream::ptellg | ( | ) |
Get position of the get pointer.
The get pointer determines the next location in the input sequence to be read by the next input operation. The function fails if no file is currently open (associated) with this object.
| void * fmstream::ptellp | ( | ) |
Get position of the put pointer.
The put pointer determines the location in the output sequence where the next output operation is going to take place. The function fails if no file is currently open (associated) with this object.
| filemappingbuf * fmstream::rdbuf | ( | ) | const |
Get the associated filemappingbuf object.
Returns a pointer to the filemappingbuf object associated with the stream.
| std::streamsize fmstream::size | ( | ) | const |
Get the maximum byte length of the mapping.
The function fails if no file is currently open (associated) with this object.
| void fmstream::swap | ( | fmstream & | stream | ) |
Swap internals (requires C++11).
Exchanges the state of the stream with those of other.
| stream | fmstream to exchange the state with. |


Proteic.js
Visualization sowcase
Areas
Barchart
Gauge
Heatmap
Linechart
Scatterplot
Streamgraph
Network
Sunburst
Swimlane
Areas
Barchart
Gauge
Heatmap
Linechart
Scatterplot
SVG
Canvas
Streamgraph
Network
Sunburst
Swimlane


NARS
NARS overviewIt works both as :
To run the application from the command line, go to the folder containing NARS.jar and type the following:
java -cp NARS.jar org.opennars.main_nogui.NARSBatch org.nars-dist/Examples/Example-NAL1-edited.txtFor more information, see NARS website, open-source project, discussion group