GCDAsyncSocket Class Reference
| Inherits from | NSObject |
| Declared in | GCDAsyncSocket.h |
Tasks
-
– init
GCDAsyncSocket uses the standard delegate paradigm,
but executes all delegate callbacks on a given delegate dispatch queue.
This allows for maximum concurrency, while at the same time providing easy thread safety. -
– initWithSocketQueue:
-
– initWithDelegate:delegateQueue:
-
– initWithDelegate:delegateQueue:socketQueue:
-
– delegate
-
– setDelegate:
-
– synchronouslySetDelegate:
-
– delegateQueue
-
– setDelegateQueue:
-
– synchronouslySetDelegateQueue:
-
– getDelegate:delegateQueue:
-
– setDelegate:delegateQueue:
-
– synchronouslySetDelegate:delegateQueue:
-
– autoDisconnectOnClosedReadStream
Traditionally sockets are not closed until the conversation is over.
However, it is technically possible for the remote enpoint to close its write stream.
Our socket would then be notified that there is no more data to be read,
but our socket would still be writeable and the remote endpoint could continue to receive our data. -
– setAutoDisconnectOnClosedReadStream:
-
– isIPv4Enabled
By default, both IPv4 and IPv6 are enabled.
-
– setIPv4Enabled:
-
– isIPv6Enabled
-
– setIPv6Enabled:
-
– isIPv4PreferredOverIPv6
-
– setPreferIPv4OverIPv6:
-
– userData
User data allows you to associate arbitrary information with the socket.
This data is not used internally by socket in any way. -
– setUserData:
-
– acceptOnPort:error:
Tells the socket to begin listening and accepting connections on the given port.
When a connection is accepted, a new instance of GCDAsyncSocket will be spawned to handle it,
and the socket:didAcceptNewSocket: delegate method will be invoked. -
– acceptOnInterface:port:error:
This method is the same as acceptOnPort:error: with the
additional option of specifying which interface to listen on. -
– connectToHost:onPort:error:
Connects to the given host and port.
-
– connectToHost:onPort:withTimeout:error:
Connects to the given host and port with an optional timeout.
-
– connectToHost:onPort:viaInterface:withTimeout:error:
Connects to the given host & port, via the optional interface, with an optional timeout.
-
– connectToAddress:error:
Connects to the given address, specified as a sockaddr structure wrapped in a NSData object.
For example, a NSData object returned from NSNetService’s addresses method. -
– connectToAddress:withTimeout:error:
This method is the same as connectToAddress:error: with an additional timeout option.
To not time out use a negative time interval, or simply use the connectToAddress:error: method. -
– connectToAddress:viaInterface:withTimeout:error:
Connects to the given address, using the specified interface and timeout.
-
– disconnect
Disconnects immediately (synchronously). Any pending reads or writes are dropped.
-
– disconnectAfterReading
Disconnects after all pending reads have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending writes. -
– disconnectAfterWriting
Disconnects after all pending writes have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending reads. -
– disconnectAfterReadingAndWriting
Disconnects after all pending reads and writes have completed.
After calling this, the read and write methods will do nothing. -
– isDisconnected
Returns whether the socket is disconnected or connected.
-
– isConnected
-
– connectedHost
Returns the local or remote host and port to which this socket is connected, or nil and 0 if not connected.
The host will be an IP address. -
– connectedPort
-
– localHost
-
– localPort
-
– connectedAddress
Returns the local or remote address to which this socket is connected,
specified as a sockaddr structure wrapped in a NSData object. -
– localAddress
-
– isIPv4
Returns whether the socket is IPv4 or IPv6.
An accepting socket may be both. -
– isIPv6
-
– isSecure
Returns whether or not the socket has been secured via SSL/TLS.
-
– readDataWithTimeout:tag:
Reads the first available bytes that become available on the socket.
-
– readDataWithTimeout:buffer:bufferOffset:tag:
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed. -
– readDataWithTimeout:buffer:bufferOffset:maxLength:tag:
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
A maximum of length bytes will be read. -
– readDataToLength:withTimeout:tag:
Reads the given number of bytes.
-
– readDataToLength:withTimeout:buffer:bufferOffset:tag:
Reads the given number of bytes.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed. -
– readDataToData:withTimeout:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
-
– readDataToData:withTimeout:buffer:bufferOffset:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed. -
– readDataToData:withTimeout:maxLength:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
-
– readDataToData:withTimeout:buffer:bufferOffset:maxLength:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed. -
– progressOfReadReturningTag:bytesDone:total:
Returns progress of the current read, from 0.0 to 1.0, or NaN if no current read (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL. -
– writeData:withTimeout:tag:
Writes data to the socket, and calls the delegate when finished.
-
– progressOfWriteReturningTag:bytesDone:total:
Returns progress of the current write, from 0.0 to 1.0, or NaN if no current write (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL. -
– startTLS:
Secures the connection using SSL/TLS.
-
– performBlock:
It’s not thread-safe to access certain variables from outside the socket’s internal queue.
-
– socketFD
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above. -
– socket4FD
-
– socket6FD
-
– readStream
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above. -
– writeStream
-
– enableBackgroundingOnSocket
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above. -
– sslContext
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above. -
+ hostFromAddress:
Extracting host and port information from raw address data.
-
+ portFromAddress:
-
+ getHost:port:fromAddress:
-
+ CRLFData
A few common line separators, for use with the readDataToData:… methods.
-
+ CRData
-
+ LFData
-
+ ZeroData
Class Methods
CRLFData
A few common line separators, for use with the readDataToData:… methods.
+ (NSData *)CRLFData
Discussion
A few common line separators, for use with the readDataToData:… methods.
Declared In
GCDAsyncSocket.h
getHost:port:fromAddress:
+ (BOOL)getHost:(NSString **)hostPtr port:(uint16_t *)portPtr fromAddress:(NSData *)address
Instance Methods
acceptOnInterface:port:error:
This method is the same as acceptOnPort:error: with the
additional option of specifying which interface to listen on.
- (BOOL)acceptOnInterface:(NSString *)interface port:(uint16_t)port error:(NSError **)errPtr
Discussion
This method is the same as acceptOnPort:error: with the
additional option of specifying which interface to listen on.
For example, you could specify that the socket should only accept connections over ethernet,
and not other interfaces such as wifi.
The interface may be specified by name (e.g. “en1” or “lo0”) or by IP address (e.g. “<IP_ADDRESS>”).
You may also use the special strings “localhost” or “loopback” to specify that
the socket only accept connections from the local machine.
You can see the list of interfaces via the command line utility “ifconfig”,
or programmatically via the getifaddrs() function.
To accept connections on any interface pass nil, or simply use the acceptOnPort:error: method.
Declared In
GCDAsyncSocket.h
acceptOnPort:error:
Tells the socket to begin listening and accepting connections on the given port.
When a connection is accepted, a new instance of GCDAsyncSocket will be spawned to handle it,
and the socket:didAcceptNewSocket: delegate method will be invoked.
- (BOOL)acceptOnPort:(uint16_t)port error:(NSError **)errPtr
Discussion
Tells the socket to begin listening and accepting connections on the given port.
When a connection is accepted, a new instance of GCDAsyncSocket will be spawned to handle it,
and the socket:didAcceptNewSocket: delegate method will be invoked.
The socket will listen on all available interfaces (e.g. wifi, ethernet, etc)
Declared In
GCDAsyncSocket.h
autoDisconnectOnClosedReadStream
Traditionally sockets are not closed until the conversation is over.
However, it is technically possible for the remote enpoint to close its write stream.
Our socket would then be notified that there is no more data to be read,
but our socket would still be writeable and the remote endpoint could continue to receive our data.
- (BOOL)autoDisconnectOnClosedReadStream
Discussion
Traditionally sockets are not closed until the conversation is over.
However, it is technically possible for the remote enpoint to close its write stream.
Our socket would then be notified that there is no more data to be read,
but our socket would still be writeable and the remote endpoint could continue to receive our data.
The argument for this confusing functionality stems from the idea that a client could shut down its
write stream after sending a request to the server, thus notifying the server there are to be no further requests.
In practice, however, this technique did little to help server developers.
To make matters worse, from a TCP perspective there is no way to tell the difference from a read stream close
and a full socket close. They both result in the TCP stack receiving a FIN packet. The only way to tell
is by continuing to write to the socket. If it was only a read stream close, then writes will continue to work.
Otherwise an error will be occur shortly (when the remote end sends us a RST packet).
In addition to the technical challenges and confusion, many high level socket/stream API’s provide
no support for dealing with the problem. If the read stream is closed, the API immediately declares the
socket to be closed, and shuts down the write stream as well. In fact, this is what Apple’s CFStream API does.
It might sound like poor design at first, but in fact it simplifies development.
The vast majority of the time if the read stream is closed it’s because the remote endpoint closed its socket.
Thus it actually makes sense to close the socket at this point.
And in fact this is what most networking developers want and expect to happen.
However, if you are writing a server that interacts with a plethora of clients,
you might encounter a client that uses the discouraged technique of shutting down its write stream.
If this is the case, you can set this property to NO,
and make use of the socketDidCloseReadStream delegate method.
The default value is YES.
Declared In
GCDAsyncSocket.h
connectToAddress:error:
Connects to the given address, specified as a sockaddr structure wrapped in a NSData object.
For example, a NSData object returned from NSNetService’s addresses method.
- (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr
Discussion
Connects to the given address, specified as a sockaddr structure wrapped in a NSData object.
For example, a NSData object returned from NSNetService’s addresses method.
If you have an existing struct sockaddr you can convert it to a NSData object like so:
struct sockaddr sa -> NSData dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
struct sockaddr sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
This method invokes connectToAdd
Declared In
GCDAsyncSocket.h
connectToAddress:viaInterface:withTimeout:error:
Connects to the given address, using the specified interface and timeout.
- (BOOL)connectToAddress:(NSData *)remoteAddr viaInterface:(NSString *)interface withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr
Discussion
Connects to the given address, using the specified interface and timeout.
The address is specified as a sockaddr structure wrapped in a NSData object.
For example, a NSData object returned from NSNetService’s addresses method.
If you have an existing struct sockaddr you can convert it to a NSData object like so:
struct sockaddr sa -> NSData dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
struct sockaddr sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
The interface may be a name (e.g. “en1” or “lo0”) or the corresponding IP address (e.g. “<IP_ADDRESS>”).
The interface may also be used to specify the local port (see below).
The timeout is optional. To not time out use a negative time interval.
This method will return NO if an error is detected, and set the error pointer (if one was given).
Possible errors would be a nil host, invalid interface, or socket is already connected.
If no errors are detected, this method will start a background connect operation and immediately return YES.
The delegate callbacks are used to notify you when the socket connects, or if the host was unreachable.
Since this class supports queued reads and writes, you can immediately start reading and/or writing.
All read/write operations will be queued, and upon socket connection,
the operations will be dequeued and processed in order.
The interface may optionally contain a port number at the end of the string, separated by a colon.
This allows you to specify the local port that should be used for the outgoing connection. (read paragraph to end)
To specify both interface and local port: “en1:8082” or “<IP_ADDRESS>:2424”.
To specify only local port: “:8082”.
Please note this is an advanced feature, and is somewhat hidden on purpose.
You should understand that 99.999% of the time you should NOT specify the local port for an outgoing connection.
If you think you need to, there is a very good chance you have a fundamental misunderstanding somewhere.
Local ports do NOT need to match remote ports. In fact, they almost never do.
This feature is here for networking professionals using very advanced techniques.
Declared In
GCDAsyncSocket.h
connectToAddress:withTimeout:error:
This method is the same as connectToAddress:error: with an additional timeout option.
To not time out use a negative time interval, or simply use the connectToAddress:error: method.
- (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr
Discussion
This method is the same as connectToAddress:error: with an additional timeout option.
To not time out use a negative time interval, or simply use the connectToAddress:error: method.
Declared In
GCDAsyncSocket.h
connectToHost:onPort:error:
Connects to the given host and port.
- (BOOL)connectToHost:(NSString *)host onPort:(uint16_t)port error:(NSError **)errPtr
Discussion
Connects to the given host and port.
This method invokes connectToHost:onPort:viaInterface:withTimeout:error:
and uses the default interface, and no timeout.
Declared In
GCDAsyncSocket.h
connectToHost:onPort:viaInterface:withTimeout:error:
Connects to the given host & port, via the optional interface, with an optional timeout.
- (BOOL)connectToHost:(NSString *)host onPort:(uint16_t)port viaInterface:(NSString *)interface withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr
Discussion
Connects to the given host & port, via the optional interface, with an optional timeout.
The host may be a domain name (e.g. “deusty.com”) or an IP address string (e.g. “<IP_ADDRESS>”).
The host may also be the special strings “localhost” or “loopback” to specify connecting
to a service on the local machine.
The interface may be a name (e.g. “en1” or “lo0”) or the corresponding IP address (e.g. “<IP_ADDRESS>”).
The interface may also be used to specify the local port (see below).
To not time out use a negative time interval.
This method will return NO if an error is detected, and set the error pointer (if one was given).
Possible errors would be a nil host, invalid interface, or socket is already connected.
If no errors are detected, this method will start a background connect operation and immediately return YES.
The delegate callbacks are used to notify you when the socket connects, or if the host was unreachable.
Since this class supports queued reads and writes, you can immediately start reading and/or writing.
All read/write operations will be queued, and upon socket connection,
the operations will be dequeued and processed in order.
The interface may optionally contain a port number at the end of the string, separated by a colon.
This allows you to specify the local port that should be used for the outgoing connection. (read paragraph to end)
To specify both interface and local port: “en1:8082” or “<IP_ADDRESS>:2424”.
To specify only local port: “:8082”.
Please note this is an advanced feature, and is somewhat hidden on purpose.
You should understand that 99.999% of the time you should NOT specify the local port for an outgoing connection.
If you think you need to, there is a very good chance you have a fundamental misunderstanding somewhere.
Local ports do NOT need to match remote ports. In fact, they almost never do.
This feature is here for networking professionals using very advanced techniques.
Declared In
GCDAsyncSocket.h
connectToHost:onPort:withTimeout:error:
Connects to the given host and port with an optional timeout.
- (BOOL)connectToHost:(NSString *)host onPort:(uint16_t)port withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr
Discussion
Connects to the given host and port with an optional timeout.
This method invokes connectToHost:onPort:viaInterface:withTimeout:error: and uses the default interface.
Declared In
GCDAsyncSocket.h
connectedAddress
Returns the local or remote address to which this socket is connected,
specified as a sockaddr structure wrapped in a NSData object.
- (NSData *)connectedAddress
Discussion
Returns the local or remote address to which this socket is connected,
specified as a sockaddr structure wrapped in a NSData object.
See also the connectedHost, connectedPort, localHost and localPort methods.
Declared In
GCDAsyncSocket.h
connectedHost
Returns the local or remote host and port to which this socket is connected, or nil and 0 if not connected.
The host will be an IP address.
- (NSString *)connectedHost
Discussion
Returns the local or remote host and port to which this socket is connected, or nil and 0 if not connected.
The host will be an IP address.
Declared In
GCDAsyncSocket.h
disconnect
Disconnects immediately (synchronously). Any pending reads or writes are dropped.
- (void)disconnect
Discussion
Disconnects immediately (synchronously). Any pending reads or writes are dropped.
If the socket is not already disconnected, an invocation to the socketDidDisconnect:withError: delegate method
will be queued onto the delegateQueue asynchronously (behind any previously queued delegate methods).
In other words, the disconnected delegate method will be invoked sometime shortly after this method returns.
Please note the recommended way of releasing a GCDAsyncSocket instance (e.g. in a dealloc method)
[asyncSocket setDelegate:nil];
[asyncSocket disconnect];
[asyncSocket release];
If you plan on disconnecting the socket, and then immediately asking it to connect again,
you’ll likely want to do so like this:
[asyncSocket setDelegate:nil];
[asyncSocket disconnect];
[asyncSocket setDelegate:self];
[asyncSocket connect…];
Declared In
GCDAsyncSocket.h
disconnectAfterReading
Disconnects after all pending reads have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending writes.
- (void)disconnectAfterReading
Discussion
Disconnects after all pending reads have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending writes.
Declared In
GCDAsyncSocket.h
disconnectAfterReadingAndWriting
Disconnects after all pending reads and writes have completed.
After calling this, the read and write methods will do nothing.
- (void)disconnectAfterReadingAndWriting
Discussion
Disconnects after all pending reads and writes have completed.
After calling this, the read and write methods will do nothing.
Declared In
GCDAsyncSocket.h
disconnectAfterWriting
Disconnects after all pending writes have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending reads.
- (void)disconnectAfterWriting
Discussion
Disconnects after all pending writes have completed.
After calling this, the read and write methods will do nothing.
The socket will disconnect even if there are still pending reads.
Declared In
GCDAsyncSocket.h
enableBackgroundingOnSocket
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
- (BOOL)enableBackgroundingOnSocket
Discussion
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
Configures the socket to allow it to operate when the iOS application has been backgrounded.
In other words, this method creates a read & write stream, and invokes:
CFReadStreamSetProperty(readStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
CFWriteStreamSetProperty(writeStream, kCFStreamNetworkServiceType, kCFStreamNetworkServiceTypeVoIP);
Returns YES if successful, NO otherwise.
Note: Apple does not officially support backgrounding server sockets.
That is, if your socket is accepting incoming connections, Apple does not officially support
allowing iOS applications to accept incoming connections while an app is backgrounded.
Example usage:
- (void)socket:(GCDAsyncSocket )sock didConnectToHost:(NSString )host port:(uint16_t)port
{
[asyncSocket performBlock:^{
[asyncSocket enableBackgroundingOnSocket];
}];
}
Declared In
GCDAsyncSocket.h
getDelegate:delegateQueue:
- (void)getDelegate:(id *)delegatePtr delegateQueue:(dispatch_queue_t *)delegateQueuePtr
init
GCDAsyncSocket uses the standard delegate paradigm,
but executes all delegate callbacks on a given delegate dispatch queue.
This allows for maximum concurrency, while at the same time providing easy thread safety.
- (id)init
Discussion
GCDAsyncSocket uses the standard delegate paradigm,
but executes all delegate callbacks on a given delegate dispatch queue.
This allows for maximum concurrency, while at the same time providing easy thread safety.
You MUST set a delegate AND delegate dispatch queue before attempting to
use the socket, or you will get an error.
The socket queue is optional.
If you pass NULL, GCDAsyncSocket will automatically create it’s own socket queue.
If you choose to provide a socket queue, the socket queue must not be a concurrent queue.
The delegate queue and socket queue can optionally be the same.
Declared In
GCDAsyncSocket.h
initWithDelegate:delegateQueue:
- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq
initWithDelegate:delegateQueue:socketQueue:
- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq socketQueue:(dispatch_queue_t)sq
isDisconnected
Returns whether the socket is disconnected or connected.
- (BOOL)isDisconnected
Discussion
Returns whether the socket is disconnected or connected.
A disconnected socket may be recycled.
That is, it can used again for connecting or listening.
If a socket is in the process of connecting, it may be neither disconnected nor connected.
Declared In
GCDAsyncSocket.h
isIPv4
Returns whether the socket is IPv4 or IPv6.
An accepting socket may be both.
- (BOOL)isIPv4
Discussion
Returns whether the socket is IPv4 or IPv6.
An accepting socket may be both.
Declared In
GCDAsyncSocket.h
isIPv4Enabled
By default, both IPv4 and IPv6 are enabled.
- (BOOL)isIPv4Enabled
Discussion
By default, both IPv4 and IPv6 are enabled.
For accepting incoming connections, this means GCDAsyncSocket automatically supports both protocols,
and can simulataneously accept incoming connections on either protocol.
For outgoing connections, this means GCDAsyncSocket can connect to remote hosts running either protocol.
If a DNS lookup returns only IPv4 results, GCDAsyncSocket will automatically use IPv4.
If a DNS lookup returns only IPv6 results, GCDAsyncSocket will automatically use IPv6.
If a DNS lookup returns both IPv4 and IPv6 results, the preferred protocol will be chosen.
By default, the preferred protocol is IPv4, but may be configured as desired.
Declared In
GCDAsyncSocket.h
isSecure
Returns whether or not the socket has been secured via SSL/TLS.
- (BOOL)isSecure
Discussion
Returns whether or not the socket has been secured via SSL/TLS.
See also the startTLS method.
Declared In
GCDAsyncSocket.h
performBlock:
It’s not thread-safe to access certain variables from outside the socket’s internal queue.
- (void)performBlock:(dispatch_block_t)block
Discussion
It’s not thread-safe to access certain variables from outside the socket’s internal queue.
For example, the socket file descriptor.
File descriptors are simply integers which reference an index in the per-process file table.
However, when one requests a new file descriptor (by opening a file or socket),
the file descriptor returned is guaranteed to be the lowest numbered unused descriptor.
So if we’re not careful, the following could be possible:
- Thread A invokes a method which returns the socket’s file descriptor.
- The socket is closed via the socket’s internal queue on thread B.
- Thread C opens a file, and subsequently receives the file descriptor that was previously the socket’s FD.
- Thread A is now accessing/altering the file instead of the socket.
In addition to this, other variables are not actually objects,
and thus cannot be retained/released or even autoreleased.
An example is the sslContext, of type SSLContextRef, which is actually a malloc’d struct.
Although there are internal variables that make it difficult to maintain thread-safety,
it is important to provide access to these variables
to ensure this class can be used in a wide array of environments.
This method helps to accomplish this by invoking the current block on the socket’s internal queue.
The methods below can be invoked from within the block to access
those generally thread-unsafe internal variables in a thread-safe manner.
The given block will be invoked synchronously on the socket’s internal queue.
If you save references to any protected variables and use them outside the block, you do so at your own peril.
Declared In
GCDAsyncSocket.h
progressOfReadReturningTag:bytesDone:total:
Returns progress of the current read, from 0.0 to 1.0, or NaN if no current read (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL.
- (float)progressOfReadReturningTag:(long *)tagPtr bytesDone:(NSUInteger *)donePtr total:(NSUInteger *)totalPtr
Discussion
Returns progress of the current read, from 0.0 to 1.0, or NaN if no current read (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL.
Declared In
GCDAsyncSocket.h
progressOfWriteReturningTag:bytesDone:total:
Returns progress of the current write, from 0.0 to 1.0, or NaN if no current write (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL.
- (float)progressOfWriteReturningTag:(long *)tagPtr bytesDone:(NSUInteger *)donePtr total:(NSUInteger *)totalPtr
Discussion
Returns progress of the current write, from 0.0 to 1.0, or NaN if no current write (use isnan() to check).
The parameters “tag”, “done” and “total” will be filled in if they aren’t NULL.
Declared In
GCDAsyncSocket.h
readDataToData:withTimeout:buffer:bufferOffset:maxLength:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger)offset maxLength:(NSUInteger)length tag:(long)tag
Discussion
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
If the timeout value is negative, the read operation will not use a timeout.
If the buffer if nil, a buffer will automatically be created for you.
If maxLength is zero, no length restriction is enforced.
Otherwise if maxLength bytes are read without completing the read,
it is treated similarly to a timeout - the socket is closed with a GCDAsyncSocketReadMaxedOutError.
The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
If you pass a maxLength parameter that is less than the length of the data (separator) parameter,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
If the bufferOffset is greater than the length of the given buffer,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
If you pass a buffer, you must not alter it in any way while the socket is using it.
After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
That is, it will reference the bytes that were appended to the given buffer via
the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the “data” parameter.
If you’re developing your own custom protocol, be sure your separator can not occur naturally as
part of the data between separators.
For example, imagine you want to send several small documents over a socket.
Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
In this particular example, it would be better to use a protocol similar to HTTP with
a header that includes the length of the document.
Also be careful that your separator cannot occur naturally as part of the encoding for a character.
The given data (separator) parameter should be immutable.
For performance reasons, the socket will retain it, not copy it.
So if it is immutable, don’t modify it while the socket is using it.
Declared In
GCDAsyncSocket.h
readDataToData:withTimeout:buffer:bufferOffset:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger)offset tag:(long)tag
Discussion
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
If the timeout value is negative, the read operation will not use a timeout.
If the buffer if nil, a buffer will automatically be created for you.
If the bufferOffset is greater than the length of the given buffer,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
If you pass a buffer, you must not alter it in any way while the socket is using it.
After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
That is, it will reference the bytes that were appended to the given buffer via
the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the “data” parameter.
If you’re developing your own custom protocol, be sure your separator can not occur naturally as
part of the data between separators.
For example, imagine you want to send several small documents over a socket.
Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
In this particular example, it would be better to use a protocol similar to HTTP with
a header that includes the length of the document.
Also be careful that your separator cannot occur naturally as part of the encoding for a character.
The given data (separator) parameter should be immutable.
For performance reasons, the socket will retain it, not copy it.
So if it is immutable, don’t modify it while the socket is using it.
Declared In
GCDAsyncSocket.h
readDataToData:withTimeout:maxLength:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(NSUInteger)length tag:(long)tag
Discussion
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
If the timeout value is negative, the read operation will not use a timeout.
If maxLength is zero, no length restriction is enforced.
Otherwise if maxLength bytes are read without completing the read,
it is treated similarly to a timeout - the socket is closed with a GCDAsyncSocketReadMaxedOutError.
The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
If you pass nil or zero-length data as the “data” parameter,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
If you pass a maxLength parameter that is less than the length of the data parameter,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the “data” parameter.
If you’re developing your own custom protocol, be sure your separator can not occur naturally as
part of the data between separators.
For example, imagine you want to send several small documents over a socket.
Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
In this particular example, it would be better to use a protocol similar to HTTP with
a header that includes the length of the document.
Also be careful that your separator cannot occur naturally as part of the encoding for a character.
The given data (separator) parameter should be immutable.
For performance reasons, the socket will retain it, not copy it.
So if it is immutable, don’t modify it while the socket is using it.
Declared In
GCDAsyncSocket.h
readDataToData:withTimeout:tag:
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag
Discussion
Reads bytes until (and including) the passed “data” parameter, which acts as a separator.
If the timeout value is negative, the read operation will not use a timeout.
If you pass nil or zero-length data as the “data” parameter,
the method will do nothing (except maybe print a warning), and the delegate will not be called.
To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the “data” parameter.
If you’re developing your own custom protocol, be sure your separator can not occur naturally as
part of the data between separators.
For example, imagine you want to send several small documents over a socket.
Using CRLF as a separator is likely unwise, as a CRLF could easily exist within the documents.
In this particular example, it would be better to use a protocol similar to HTTP with
a header that includes the length of the document.
Also be careful that your separator cannot occur naturally as part of the encoding for a character.
The given data (separator) parameter should be immutable.
For performance reasons, the socket will retain it, not copy it.
So if it is immutable, don’t modify it while the socket is using it.
Declared In
GCDAsyncSocket.h
readDataToLength:withTimeout:buffer:bufferOffset:tag:
Reads the given number of bytes.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger)offset tag:(long)tag
Discussion
Reads the given number of bytes.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
If the timeout value is negative, the read operation will not use a timeout.
If the buffer if nil, a buffer will automatically be created for you.
If the length is 0, this method does nothing and the delegate is not called.
If the bufferOffset is greater than the length of the given buffer,
the method will do nothing, and the delegate will not be called.
If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
That is, it will reference the bytes that were appended to the given buffer via
the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
Declared In
GCDAsyncSocket.h
readDataToLength:withTimeout:tag:
Reads the given number of bytes.
- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag
Discussion
Reads the given number of bytes.
If the timeout value is negative, the read operation will not use a timeout.
If the length is 0, this method does nothing and the delegate is not called.
Declared In
GCDAsyncSocket.h
readDataWithTimeout:buffer:bufferOffset:maxLength:tag:
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
A maximum of length bytes will be read.
- (void)readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger)offset maxLength:(NSUInteger)length tag:(long)tag
Discussion
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
A maximum of length bytes will be read.
If the timeout value is negative, the read operation will not use a timeout.
If the buffer if nil, a buffer will automatically be created for you.
If maxLength is zero, no length restriction is enforced.
If the bufferOffset is greater than the length of the given buffer,
the method will do nothing, and the delegate will not be called.
If you pass a buffer, you must not alter it in any way while the socket is using it.
After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
That is, it will reference the bytes that were appended to the given buffer via
the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
Declared In
GCDAsyncSocket.h
readDataWithTimeout:buffer:bufferOffset:tag:
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
- (void)readDataWithTimeout:(NSTimeInterval)timeout buffer:(NSMutableData *)buffer bufferOffset:(NSUInteger)offset tag:(long)tag
Discussion
Reads the first available bytes that become available on the socket.
The bytes will be appended to the given byte buffer starting at the given offset.
The given buffer will automatically be increased in size if needed.
If the timeout value is negative, the read operation will not use a timeout.
If the buffer if nil, the socket will create a buffer for you.
If the bufferOffset is greater than the length of the given buffer,
the method will do nothing, and the delegate will not be called.
If you pass a buffer, you must not alter it in any way while the socket is using it.
After completion, the data returned in socket:didReadData:withTag: will be a subset of the given buffer.
That is, it will reference the bytes that were appended to the given buffer via
the method [NSData dataWithBytesNoCopy:length:freeWhenDone:NO].
Declared In
GCDAsyncSocket.h
readDataWithTimeout:tag:
Reads the first available bytes that become available on the socket.
- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag
Discussion
Reads the first available bytes that become available on the socket.
If the timeout value is negative, the read operation will not use a timeout.
Declared In
GCDAsyncSocket.h
readStream
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
- (CFReadStreamRef)readStream
Discussion
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
Provides access to the socket’s internal CFReadStream/CFWriteStream.
These streams are only used as workarounds for specific iOS shortcomings:
Apple has decided to keep the SecureTransport framework private is iOS.
This means the only supplied way to do SSL/TLS is via CFStream or some other API layered on top of it.
Thus, in order to provide SSL/TLS support on iOS we are forced to rely on CFStream,
instead of the preferred and faster and more powerful SecureTransport.If a socket doesn’t have backgrounding enabled, and that socket is closed while the app is backgrounded,
Apple only bothers to notify us via the CFStream API.
The faster and more powerful GCD API isn’t notified properly in this case.
See also: (BOOL)enableBackgroundingOnSocket
Declared In
GCDAsyncSocket.h
setDelegate:delegateQueue:
- (void)setDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue
socketFD
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
- (int)socketFD
Discussion
These methods are only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
Provides access to the socket’s file descriptor(s).
If the socket is a server socket (is accepting incoming connections),
it might actually have multiple internal socket file descriptors - one for IPv4 and one for IPv6.
Declared In
GCDAsyncSocket.h
sslContext
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
- (SSLContextRef)sslContext
Discussion
This method is only available from within the context of a performBlock: invocation.
See the documentation for the performBlock: method above.
Provides access to the socket’s SSLContext, if SSL/TLS has been started on the socket.
Declared In
GCDAsyncSocket.h
startTLS:
Secures the connection using SSL/TLS.
- (void)startTLS:(NSDictionary *)tlsSettings
Discussion
Secures the connection using SSL/TLS.
This method may be called at any time, and the TLS handshake will occur after all pending reads and writes
are finished. This allows one the option of sending a protocol dependent StartTLS message, and queuing
the upgrade to TLS at the same time, without having to wait for the write to finish.
Any reads or writes scheduled after this method is called will occur over the secured connection.
The possible keys and values for the TLS settings are well documented.
Standard keys are:
- kCFStreamSSLLevel
- kCFStreamSSLAllowsExpiredCertificates
- kCFStreamSSLAllowsExpiredRoots
- kCFStreamSSLAllowsAnyRoot
- kCFStreamSSLValidatesCertificateChain
- kCFStreamSSLPeerName
- kCFStreamSSLCertificates
- kCFStreamSSLIsServer
If SecureTransport is available on iOS:
- GCDAsyncSocketSSLCipherSuites
- GCDAsyncSocketSSLProtocolVersionMin
- GCDAsyncSocketSSLProtocolVersionMax
If SecureTransport is available on Mac OS X:
- GCDAsyncSocketSSLCipherSuites
- GCDAsyncSocketSSLDiffieHellmanParameters;
Please refer to Apple’s documentation for associated values, as well as other possible keys.
If you pass in nil or an empty dictionary, the default settings will be used.
The default settings will check to make sure the remote party’s certificate is signed by a
trusted 3rd party certificate agency (e.g. verisign) and that the certificate is not expired.
However it will not verify the name on the certificate unless you
give it a name to verify against via the kCFStreamSSLPeerName key.
The security implications of this are important to understand.
Imagine you are attempting to create a secure connection to MySecureServer.com,
but your socket gets directed to MaliciousServer.com because of a hacked DNS server.
If you simply use the default settings, and MaliciousServer.com has a valid certificate,
the default settings will not detect any problems since the certificate is valid.
To properly secure your connection in this particular scenario you
should set the kCFStreamSSLPeerName property to “MySecureServer.com”.
If you do not know the peer name of the remote host in advance (for example, you’re not sure
if it will be “domain.com” or “www.domain.com”), then you can use the default settings to validate the
certificate, and then use the X509Certificate class to verify the issuer after the socket has been secured.
The X509Certificate class is part of the CocoaAsyncSocket open source project.
Declared In
GCDAsyncSocket.h
synchronouslySetDelegate:delegateQueue:
- (void)synchronouslySetDelegate:(id)delegate delegateQueue:(dispatch_queue_t)delegateQueue
synchronouslySetDelegateQueue:
- (void)synchronouslySetDelegateQueue:(dispatch_queue_t)delegateQueue
userData
User data allows you to associate arbitrary information with the socket.
This data is not used internally by socket in any way.
- (id)userData
Discussion
User data allows you to associate arbitrary information with the socket.
This data is not used internally by socket in any way.
Declared In
GCDAsyncSocket.h
writeData:withTimeout:tag:
Writes data to the socket, and calls the delegate when finished.
- (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag
Discussion
Writes data to the socket, and calls the delegate when finished.
If you pass in nil or zero-length data, this method does nothing and the delegate will not be called.
If the timeout value is negative, the write operation will not use a timeout.
Thread-Safety Note:
If the given data parameter is mutable (NSMutableData) then you MUST NOT alter the data while
the socket is writing it. In other words, it’s not safe to alter the data until after the delegate method
socket:didWriteDataWithTag: is invoked signifying that this particular write operation has completed.
This is due to the fact that GCDAsyncSocket does NOT copy the data. It simply retains it.
This is for performance reasons. Often times, if NSMutableData is passed, it is because
a request/response was built up in memory. Copying this data adds an unwanted/unneeded overhead.
If you need to write data from an immutable buffer, and you need to alter the buffer before the socket
completes writing the bytes (which is NOT immediately after this method returns, but rather at a later time
when the delegate method notifies you), then you should first copy the bytes, and pass the copy to this method.
Declared In
GCDAsyncSocket.h


Flexhang1357.github.io
Citizen Sr-260N Anweisungshandbuch.
CITIZEN 350DPA INSTRUCTION MANUAL Pdf Download. View and Download Citizen 350DPA instruction manual online. Citizen Printing Calculator Instruction manual. 350DPA Calculator pdf manual download.


Overcrowded classrooms, scarce materials, outdated teaching methods and excessive punishments prevent students in underserved communities from acquiring the knowledge they need to be successful later in life.
It’s a problem that isn’t limited to developing countries. In the United States, low-income and rural students consistently show major achievement gaps compared to their more affluent peers.
The Oppia Foundation believes these gaps can be narrowed by ensuring that all students have access to a set of free, engaging, and demonstrably effective lessons that they can use at any time.
We want to give students of all backgrounds a chance to learn the skills they need to build brighter futures for themselves and their communities.
In collaboration with our global community of educators, we are building a library of free lessons that provide personalized feedback, thus providing any student around the world with an experience that mimics one-on-one tutoring. We plan to use techniques like machine learning to make Oppia’s guidance for students as specific and useful as possible.
By raising awareness of these lessons, so that students who need them know that they can use them to learn effectively, we hope to remove as many barriers as possible between students and the education they deserve.
In 2018, we conducted a randomized trial of our Fractions lessons with students from Delhi, India. Across topics encountered by all students in the study, we found that students in the Oppia treatment group scored significantly better on the post-test than their control-group counterparts. 100% of the students said that they would recommend Oppia lessons to their friends.
Furthermore, user studies with students around the world (including places as diverse as the USA, India, Cameroon, Portugal and Zimbabwe) repeatedly show that they enjoy the Oppia lessons and find them useful.
Building a dynamic, global community to transform online learning is a bold vision that requires generous support.
That's why your help is so important.
Here are some of the challenges that your involvement can help us tackle in the near future:
We’re incredibly excited about what’s going on at Oppia. We are looking for organizations that want to join us on our journey to transform how students learn online.
There’s a lot more that we have to share about the promise of our platform. Email us or fill out this form for more information, questions, or to learn about partnership opportunities.
We’ll get back to you as soon as possible!


Analysis of emergency calls in San Francisco to predict trends using interactive visualization Created by Neal Patel
You can download Grayscale for free on the preview page at Start Bootstrap.
Feel free to leave us a comment on the Grayscale template overview page on Start Bootstrap to give some feedback about this theme!


{% extends "layout_unbranded.html" %} {% block page_title %} Suspend a notice of eviction {% endblock %} {% block content %} Date of the eviction Day Month Year at 10:00AM Continue {% endblock %}
at 10:00AM


MobStr is a project designed to provide an ORM-like interface to a MobX store. The goal of this project is to achieve a low-overhead, normalized approach to modeling to allow developers to focus on domain modeling without having to deal with manual book-keeping of object relationships. It also provides an opt-in approach to constraint checking, which can lead to better performance since we simply don't check every field.
Additionally, it's actually fairly easy to make certain guarantees that MobX provides invalid by complete accident, especially when copying string keys from observable objects into another observable. The answer is to leverage computed
or autorun
or other reaction-based functions, but this library should abstract over those to the point where the user doesn't need to necessarily worry about committing error-prone code in these specialized cases.
There do exist other solutions in the MobX examples and they are perfectly valid, but they require passing around parent contexts and there isn't an out of the box solution for saying "I have all of these models that I know are related to parents, but I just want these without looping through all of the parents". Consider this example store code loosely lifted from the MobX documentation:
class ToDo {
constructor(store) {
this.store = store;
}
}
class Parent {
@observable todos = []
makeTodo() {
this.todos.push(new ToDo(this));
}
}
Full and complete sample here: https://mobx.js.org/best/store.html
This requires only a simple flatmap to achieve the desired output of a list of all ToDos, but more complicated relationships would easily become more cumbersome. For example, take the following code snippet:
class Step {}
class ToDo {
@observable steps = [];
makeStep() {
this.steps.push(new Step(this))
}
constructor(store) {
this.store = store;
}
}
class Parent {
@observable todos = []
makeTodo() {
this.todos.push(new ToDo(this));
}
}
The overall approach is still the same (flatMap with a greater depth to get all Steps from all ToDos), but it would be nice to simply query for all of the steps that currently exist in isolation, or all ofthe ToDos that currently exist without having to traverse the parent contexts.
With this project, I hope to separate the concerns of managing a centralized store with an accessible syntax for describing model relationships and model structure. Eventually I also hope to integrate nice-to-have features, such as index only lookups, complex primary key structures, and relationship cascade options.
All told, this project is about 200 lines of actual code (so far!), with most of the actual code lying in the decorators to set up meta attributes and maintain book-keeping, so it should achieve a very similar result to mobx-state-tree while cutting down on the complexity. LOC isn't a great metric for complexity or scope but it's what I have on hand.
As of now, the form that the __meta__
attribute takes is this:
__meta__: {
key: IObservableValue<string | symbol | number | null>;
collectionName: string | symbol | number;
relationships: Record<
string | symbol,
{
type: any;
keys: IObservableArray<string>;
options: Record<string, any>;
}
>;
indicies: IObservableArray<string | symbol | number>;
};
Example of "proper" typing of class attributes:
class Bar {
@primaryKey
id: string = uuid();
}
class Foo {
@primaryKey
id: string = uuid();
@relationship(type => Bar)
friends: Bar[] = [];
}
const f = new Foo();
f.friends[0].id // This properly gives us type hints because we've typed it as a Bar[]. We could have also typed it as an IObservableArray
At this time, the recommended way to use POJOs in this library is similar to this example code:
class Foo {
@primaryKey
id = uuid();
@observable
someProperty = []
}
// returnValue = { status: 200, data: {id: '1234', someProperty: [1, 2, 3, 4] }}
function apiCallResult(returnValue) {
// Validate
...
// Dump the result into a new instance of the model
const f = Object.assign(new Foo(), returnValue.data);
add(f);
return f;
}
class Foo {
@primaryKey
id: string = uuid();
@relationship(store, () => Foo, { cascade: true })
leaves: Foo[] = [];
}
const foo = new Foo();
const leaves = [new Foo(), new Foo()];
const otherLeaves = [new Foo(), new Foo()];
addOne(store, foo);
foo.leaves.push(...leaves);
leaves[0].leaves.push(...otherLeaves);
findAll(Foo).length === 5;
removeOne(foo);
findAll(Foo).length === 0;
However, this does still have the same limitations as POJOs currently do, so you can't directly shove a JSON structure into the store, there has to be a preprocessing step. However, a nice side effect of this is the ability to gather all Foo objects in a single query without walking the entirety of the tree.
At this time, no. It has a lot to do with when javascript class definitions are evaluated. For an example of what I'm talking about, please reference the below code:
class Bar {
@primaryKey;
id = uuid()
@relationship(() => Foo)
foos = [];
}
class Foo {
@primaryKey
id = uuid();
@relationship(() => Bar)
bars = []
}
At class definition time, "Foo" as a type is undefined, so the overall code will fail. I hope to eventually allow for these kinds of structures by using some form of lazy evalutaion on relationship definitions, similar to the method employed by SQLAlchemy.
No, since the decorator specification doens't allow for usage of decorators within anonymous classes, there's not much that MobStr can do at this time. I hope that in the future we could allow for something like this, since it could open up doors for dynamic model creation, although I'm not sure if that's a great idea or a terrible idea.
You can find some comprehensive toy examples in tests/integration.test.ts. Below is an example of real-world(ish) example using a fetch to get a company name and the a list of employees from that company.
import { observable, computed } from 'mobx';
import createStore from 'mobstr';
const {
relationship,
primaryKey,
addAll,
findOne,
removeOne,
truncateCollection,
} = createStore();
class Employee {
@primaryKey
id = uuid()
}
class Company {
@primaryKey
id = uuid()
name;
@observable
affiliates = []
@relationship(type => Employee)
employees = [];
@computed
get employeeIds() { return this.employees.map(employee => employee.id); }
}
async function getAllCompanies(companyIds) {
const companyData = await Promise.all(
companyIds.map(companyId => fetch(`/url/for/company/${companyId}`)
);
companyData.forEach(company => {
// Get all of the employee objects from the DB
const employees = await Promise.all(
company.employees.map(employee => fetch(`/url/for/company/employee/${employee}`))
);
// Note that this would overwrite any existing employees with the same ID in the data store, so make sure your IDs are unique!
company.employees = employees.map(employee => Object.assign(new Employee(), employee))
});
return companyData.map(company => Object.assign(new Company(), company));
}
// Top level await for illustrative purposes only
addAll(await getAllCompanies([1, 2, 3, 4))
findOne(Company, 1).employees.push(new Employee());
...
// Maybe we want to show a table of the company in one column with an employee in the other
join(Company, Employees).map((company, employee) => [company.id, employee.id])
...
function destroyCompany(companyId) {
findOne(Company, companyId).employees = [];
// If we had cascade: true in our relationship options, we could also delete the company from the store like so:
// removeOne(findOne(Company, companyId));
}
// Example of a react component to display all companies and with a button to delete all employees for a given company
function ShowAllCompanies(props) {
const companies = findAll(Company);
return (

{
companies.map(company => (

{company.name}
<button onClick={destroyCompany.bind(null, company.id)}>Destroy {company.name}?</button>

))
}

);
}
This does require decorator support for now, so follow the instructions for enabling babel decorator support here: https://babeljs.io/docs/en/babel-plugin-proposal-decorators
If using TypeScript, enable the "experimentalDecorators" flag in tsconfig.json, instructions located here: https://www.typescriptlang.org/docs/handbook/decorators.html
If using Create-React-App in conjunction with this project and don't wish to eject, please use react-app-rewired to override the babel settings, located here: https://github.com/timarney/react-app-rewired
This project uses mocha/chai for testing purposes. To invoke, use npm test
to run the test suite.
We use SemVer for versioning. For the versions available, see the tags on this repository.
This project is licensed under the MIT License - see the LICENSE.md file for details
Generated using TypeDoc


Hello! I'm Omar, and I help data-intensive companies be smarter and go faster by leveraging data, cloud, software, and Machine Learning.
Do you need help with Smart Platforms? Schedule a free 30min call!
BE SMARTER. GO FASTER.
As a client of mine you get top quality solutions and you get them fast. We will work together using Agile values and principles to converge to value.
"Omar is one of the most professional and highly skilled engineers I have ever worked with in my 20 years delivering technology. His role was Lead Architect and Data Scientist on a program to develop a custom Machine Learning Platform for a top 10 global telecom client. The work he delivered exceeded client expectations and has been a foundation for our clients ML journey for the next few years."
"Omar is a dedicated professional that knows how to get things done. He was a pleasure to work with and is incredibly capable and helpful. Hire him whenever you need something done right, or when you need something impossible pulled out of a hat. He is a life saving wizard... He will cast a spell and make results magically appear! Trust me on this one."
"First time request with a large budget. Omar was excellent as always. He was quick to understand the brief. Came back very quickly with interim results of his work for review, was flexible on time for video calls and delivered as requested on time and budget. Hugely impressed and will use again. Many thanks Omar!"
You can find more client reviews in my Codementor Profile.
Smart Platforms (SPs) combine software, data, cloud, and Machine Learning (ML) to enhance your team's performance. Companies making periodic decisions based on data, can leverage smart automation to improve those decisions.
SPs often make better decisions than humans for complex problems with lots of data. Do you need to constantly make complex decisions?
Learn moreSPs can produce hundreds of decisions per second for a given problem. Do you need to constantly make fast decisions?
Learn moreSPs can be seen as black boxes at times but they don't always have to be. Do you need to understand each decision?
Learn moreSPs can update themselves with the latest data. Do you need to stop wasting time on things that can be automated?
Learn moreSPs can be scaled to serve very large workloads. Do you need to constantly produce large numbers of decisions?
Learn moreSPs continuously evolve based on new data and human feedback. Do you need your decisions to be continuously improved?
Learn moreYou've hired smart people and you generate a lot of data but everyone is frustrated by how slow and incorrect insights are. Business blames analysis, analysis blames technology, and everyone blames management.
I can help you understand where better strategies, processes, techniques, and tools can enhance your teams.
At a high-level, it's a shift in thinking. Your teams will stop thinking of decisions as batches supported by spreadsheets and will think of them as automated streams. Your governance model will change as you redefine success and risk.
I'll work with your business, analysis, and technology teams to introduce the shift in thinking and coach them throughout.
Only if you don't involve them. If you tell them what you are doing and involve them in defining and shaping the new way of thinking they will come up with ideas you would never have thought of, and will more easily embrace the change.
Smart people want to do valuable work, not busy-work that can be automated, and I will help them do just that.
Do you need help with any of the above?
Get startedI appreciate receiving any comments, questions, or content requests you may have.
Smart Platforms, including those using AI and ML, can provide significant value by letting computers do work that can be automated and letting humans do creative thinking.
"93% of companies believe they will receive strategic value from AI." —BCG
"84% of C-levels believe AI is necessary to achieve growth goals." —Accenture
"76% of C-level executives believe they need AI to stay in business."—Gartner
"AI increases ROI over other techniques in 69% of use cases." —McKinsey
"AI projects give companies an average payback period of 6 months." —IBM
"33% of executives say AI will transform their business within 3 years." —Deloitte
Are you ready to move your company forward?
Get startedI appreciate receiving any comments, questions, or content requests you may have.
Building Smart Platforms requires knowledge in different types of engineering as well as on the problems being solved. That's why we will work very closely.
Do you have a strong valuable strategy? Why are you building this? Why is it needed? Is it that bad if you don't actually build this?
Learn moreCan you manage complex projects? Do you understand the underlying concepts? How can you make the most of everyone's time?
Learn moreDo you have a fast team? Do you continuously deploy? Do you often check for value? Do you feel comfortable under uncertainty?
Learn moreDo you know what ML models are the best fit for your problem? Do you know their trade-offs? Do you know how much data you need?
Learn moreDo you know how to increase the potential of your data? Do you know how to efficiently and securely move data around?
Learn moreDo you know which cloud services are the best fit for your problems? Can you easily setup, secure, and update cloud architectures?
Learn moreDo you know what databases are the best fit for your problem? Do you know how to setup and and use those databases efficiently?
Learn moreCan you easily build and connect the different parts of your architecture? Are you able to setup robust endpoints efficiently?
Learn moreAre your target users able to easily and securely consume data and ML outputs? Can you build intuitive user experiences?
Learn moreDo you need help with any of the above?
Get startedDo you have questinos about your own projects? Join the Smart Community to get answers from me.


Close
About Me
Panama Wallace
Creative Industries and Information Technology Graduate.
Menu
Typography
Posters
Photography
Something & Else
Contact
Search
Panama Jane
W
Typography
,
Posters
Typography Marketing Tiles
Typography
,
Posters
Whale Font Poster
Photography
Textured Fauna Part 1
Photography
Textured Fauna Part 2
Photography
Jekyll & Hyde Poster
Typography
,
Posters
Reimagining Book Covers
Something & Else
Social Media Tiles
Typography
,
Posters
Social Media Tiles
Something & Else
Geometric Heart
Something & Else
Brain Vector
Photography
Portraits
Photography
A Wildlife In The Mountain of India
Photography
We Took A Photo
March 6th, 2019
Typography
,
Posters
A Modernize Huge and Beautiful Building
March 6th, 2019
Something & Else
Enjoying the Native Juice Drink in Brazil
March 6th, 2019
Typography
,
Posters
Boat Travel in The Vietnam River
March 6th, 2019


{% extends 'base.html' %} {% import 'macros.html' as macro %} {% block content %}
Every now and then we get preoccupied with stuff, meeting friends, work and what not. This app will help users list and preview news articles from various sources.


|
GrPPI
1.0
Generic and Reusable Parallel Pattern Interface
|
The reduce pattern is a data pattern that combines all the values in a data set using a binary combination operation.
The interface to the reduce pattern is provided by function grppi::reduce()
. As all functions in GrPPI, this function takes as its first argument an execution policy.
There is a single variant of the reduction:
The key element of a reduction is the Combiner operation.
A Combiner is any C++ callable entity, that is able to combine two values into a single value. A Combiner cmb
is any operation taking two values x
and y
of types T
and U
and returning a combined value of type T
, making valid the following:
Performs a reduction of a sequence of values x1, x2, ..., xN
by combining them with a Combiner cmb
that has an identity value id
. The first argument of a combination may be either the identity value or the result of another combination. The combinations assume that cmb
is associative, but not commutative. Consequently, different associative orders may be used:
cmb(cmb(cmb(cmb(cmb(id,x1),x2),x3), ...),xN)
cmb(cmb(cmb(cmb(id,x1),x2),cmb(cmb(id,x3),x4)),...)
The only interface currently offered for this pattern is based in iterators (following the C++ standard library conventions):
Example: Add the lenghts of a sequence of strings.
Note: Reducing with identity value an empty sequence has a result the identity value.


First Culture Post. From Sushi eater To Coding chef
October 10, 2014
I was the general manager of 4 Japanese restaurants in New York. I had almost 80 employees followed, great salary and accommodation was provided. The relationship with my boss was very good, and he supported my professional visa and green card. It seemed so perfect that everyone does not understand why I do not work there anymore and challenge something new to me. While working there, I always dreamed of something I could contribute to more population with goodwill. Since I was interested in On-line education platform and I saw the potentialities, I decided to learn how to built websites.
Sushi and Coding must have some commons. That is why Steve jobs loved Japanese culture.
So, Why DVC? My impression of DBC is always dark red-colored wall-block and yoga,because when I see the pics of DVC, the wall is always shown. Even though I am scary to do yoga, I like DVC loving the idea of meditation and so on. This is far different from the others. In order to engage myself with this type of culture, I should change myself first. I went back to my country for a while and to prepare for DVC. Today I watched Shereef's video and he expected us to have table mind set, not restaurant mindset.Simply, Shereef asked us to be a member, not a guest. With the table mindset, I will take ownership and cook,eat and share the foods( coding ) and act as one member of DVC. I will not stand behind, and I will do my best not let my peers behind of me. I am pretty much excited to participate in this kind of learning environment. I know it is tough and intense. Of course,I am little nervous whether I can finish the course successfully with my peers. Everything is up to my mind. I will continue and overcome all kind of hardships with this mindset. Thank you!


The source of any Faunus job is a FaunusGraph
. FaunusGraph
is simply a wrapper to a collection of Hadoop- and Faunus-specific configurations. Most importantly, it captures the location and type of the input graph and output graph. A FaunusGraph
is typically created using one of the FaunusFactory.open()
methods.
A Faunus configuration file is used to construct a FaunusGraph
. Assume a file named bin/faunus.properties
as represented below.
# input graph parameters
faunus.graph.input.format=com.thinkaurelius.faunus.formats.graphson.GraphSONInputFormat
faunus.input.location=graph-of-the-gods.json
# output data parameters
faunus.graph.output.format=com.thinkaurelius.faunus.formats.graphson.GraphSONOutputFormat
faunus.sideeffect.output.format=org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
faunus.output.location=output
faunus.output.location.overwrite=true
With FaunusFactory
, a configuration file is turned in a FaunusGraph
. The toString()
of the FaunusGraph
denotes the input and output format of the graph. For instance, as seen below, a graph of type GraphSON is the input and a graph of type GraphSON is the output.
gremlin> g = FaunusFactory.open('bin/faunus.properties')
==>faunusgraph[graphsoninputformat->graphsonoutputformat]
A FaunusGraph
is loaded with Hadoop specific configuration information that is percolated from the master cluster configuration (e.g. set up during cluster construction) to various job level configurations.
gremlin> g.getConfiguration()
==>keep.failed.task.files=false
==>io.seqfile.compress.blocksize=1000000
==>dfs.df.interval=60000
==>dfs.datanode.failed.volumes.tolerated=0
==>mapreduce.reduce.input.limit=-1
==>mapred.task.tracker.http.address=<IP_ADDRESS>:50060
==>mapred.userlog.retain.hours=24
==>dfs.max.objects=0
==>dfs.https.client.keystore.resource=ssl-client.xml
==>mapred.local.dir.minspacestart=0
...
Note, it is possible to provide a prefix to look for in FaunusGraph.getConf(String prefix)
.
gremlin> g.getConf('mapred')
==>mapred.disk.healthChecker.interval=60000
==>mapred.task.tracker.http.address=<IP_ADDRESS>:50060
==>mapred.userlog.retain.hours=24
==>mapred.local.dir.minspacestart=0
==>mapred.cluster.reduce.memory.mb=-1
==>mapred.reduce.parallel.copies=5
...
Within the global configuration, there are Faunus-specific configurations. These properties can be isolated with FaunusGraph.getConf('faunus')
. In general, any prefix string can be provided (e.g. mapred
or mapred.map
).
gremlin> g.getConf('faunus')
==>faunus.graph.input.format=com.thinkaurelius.faunus.formats.graphson.GraphSONInputFormat
==>faunus.input.location=graph-of-the-gods.json
==>faunus.graph.output.format=com.thinkaurelius.faunus.formats.graphson.GraphSONOutputFormat
==>faunus.sideeffect.output.format=org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
==>faunus.output.location=output
==>faunus.output.location.overwrite=true
Moreover, FaunusGraph
provides getters/setters for mutating the most commonly used properties.
gremlin> g.setGraphOutputFormat(NoOpOutputFormat.class)
==>null
gremlin> g
==>faunusgraph[graphsoninputformat->noopoutputformat]
gremlin> g.getGraphOutputFormat()
==>class com.thinkaurelius.faunus.formats.noop.NoOpOutputFormat
gremlin> g.getProperties()
==>faunus.graph.input.format=com.thinkaurelius.faunus.formats.graphson.GraphSONInputFormat
==>faunus.input.location=graph-of-the-gods.json
==>faunus.graph.output.format=com.thinkaurelius.faunus.formats.noop.NoOpOutputFormat
==>faunus.sideeffect.output.format=org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
==>faunus.output.location=output
==>faunus.output.location.overwrite=true
To conclude, a useful FaunusGraph
method is getNextGraph()
. This method generates a new FaunusGraph
that is the “inverse” of the current with the input formats and output locations reconfigured to support easy graph chaining.
gremlin> g = FaunusFactory.open('bin/faunus.properties')
==>faunusgraph[graphsoninputformat->graphsonoutputformat]
gremlin> h = g.getNextGraph()
==>faunusgraph[graphsoninputformat->graphsonoutputformat]
gremlin> h.getConf('faunus')
==>faunus.graph.input.format=com.thinkaurelius.faunus.formats.graphson.GraphSONInputFormat
==>faunus.input.location=output/job-1
==>faunus.graph.output.format=com.thinkaurelius.faunus.formats.graphson.GraphSONOutputFormat
==>faunus.sideeffect.output.format=org.apache.hadoop.mapreduce.lib.output.TextOutputFormat
==>faunus.output.location=output_
==>faunus.output.location.overwrite=true


Dashboard
Results
{{email}} |
Log Out
Layout Score
Current
... elements total
... matched
... need investigation
Chrome Channels
BASE
Stable
Layout of page
...
on
Latest Run
Enable Element Overlay
- baseline


Studio ICD
Apps
Adventure is deep in the jungle. Precious jungle tiles have become incredibly valuable. The right tile mined at the right time can be worth a fortune. If you can mine enough of the right tiles, you can travel deeper into the jungle and discover new tiles. If too many of the wrong tiles build up, game over!
Legend has it, the Nexus Tile can destroy everything in sight. With this stone who knows what you can accomplish.
Good Luck.
~~
Nexus Tile is a puzzle game built around breaking tiles and completing challenges. If you can mine the correct tiles, you'll be able to unlock their powers and reach new heights. Challenge your friends... and your enemies with tiles that you discover. New tiles and levels are constantly emerging so keep coming back to discover them all.
Adventure is deep in the jungle. Precious jungle tiles have become incredibly valuable. The right tile mined at the right time can be worth a fortune. If you can mine enough of the right tiles, you can travel deeper into the jungle and discover new tiles. If too many of the wrong tiles build up, game over!
Legend has it, the Nexus Tile can destroy everything in sight. With this stone who knows what you can accomplish.
Good Luck.
~~
Nexus Tile is a puzzle game built around breaking tiles and completing challenges. If you can mine the correct tiles, you'll be able to unlock their powers and reach new heights. Challenge your friends... and your enemies with tiles that you discover. New tiles and levels are constantly emerging so keep coming back to discover them all.


Whether a web app or a mobile app or just some random thought that could possibly solve a real world problem , we're excited to see what you make and how you make. You can create the next big tech thing in the world. The winners will have a chance to become a part of the HACKSQUAD.
Title Sponcer
GitHub brings together the world's largest community of developers to discover, share, and build better software.
Gitlab
GitLab is a web-based Git-repository manager with wiki, issue-tracking and CI/CD pipeline features, developed by GitLab Inc.
Hackerearth
HackerEarth is a startup technology company based in Bangalore, India that provides recruitment solutions.
Balsamiq
Balsamiq is a rapid wireframing tool that helps you Work Faster & Smarter. It reproduces the experience of sketching on a whiteboard.
Tech Domains
.tech is the de facto online address for programmers, startups, tech brands, influencers and enthusiasts, the world over.
Digital Ocean
DigitalOcean provides developers cloud services that help to deploy and scale applications that run simultaneously on multiple computers.


Oct 18th, 2017
#ui #design
Oct 11th, 2017
#kotlin #android
Oct 3rd, 2017
#ui #design
Sep 23rd, 2017
#kotlin #programming #android
Aug 18th, 2017
#kotlin #programming #android
Aug 5th, 2017
#design #android
Aug 1st, 2017
#design #android
Jul 22th, 2017
#design
Jul 21th, 2017
#design
Jul 13th, 2017
#android
Jun 27th, 2017
#android
Jun 9th, 2017
#startup
May 29th, 2017
#android
May 8th, 2017
#life
April 27th, 2017
#android
April 13th, 2017
#android


Topics
- R GUIs
- R commander (Rcmdr): https://www.rcommander.com/
- Deducer: http://www.deducer.org/pmwiki/pmwiki.php?n=Main.DeducerManual
- Randomness statistical moments (mean, variance, skewness, kurtosis) explained (13 min): https://www.youtube.com/watch?v=jL9en6NvQfk&list=PL8dPuuaLjXtNM_Y-bUAhblSAdWRnmBUcr&index=18


All data, charts, and other content is available under the Creative Commons CC0 dedication. Privacy Policy.


kool
Build software development environments from the command-line.
More information: home page
- Create a project using a specific preset:
kool create preset project_name
- Run a specific script defined in the `kool.yml` file in the current directory:
kool run script
- Start/stop services in the current directory:
kool start|stop
- Display status of the services in the current directory:
kool status
- Update to the latest version:
kool self-update
- Print the completion script for the specified shell:
kool completion bash|fish|powershell|zsh


Have you ever been vacationing somewhere and wanted to get away from it all and fish but don't know where to go? We've got you covered! Just create a free profile and you will be able to see all of the fishing spots in your area! You can see what fish have been caught there using what lures and over how much time. When you're done fishing upload your own fishing data to the fishing spot to help others. You'll also be able to view all of your past uploads incase you forget where you caught that trophy fish.
"Fish Friends is such a smooth intuitive experience I love it!"
"When I was on a business trip and had some downtime I wanted to go fishing but I wasn't familiar with the area. That's when I found Fish Friends! It was so easy to use, I was able to find a spot quickly and get fishing fast."
"My buddy and I were trying to plan a fishing roadtrip but other sites were so clunky it was discouraging! Fish Friends saved our roadtrip! Thanks for making a great site!"


Device orientation and motion test for devices with acceleromters
Absolute:
Alpha:
Beta:
Gamma:
Acceleration X:
Acceleration Y:
Acceleration Z:
Interval:


---
title: UC Browser
category: Mobile
order: 60
---
Changing your search engine to DuckDuckGo
- Click on Search on the UC Browser homescreen.
- Click on the Google logo next to the search box.
- Select DuckDuckGo from the dropdown menu.
- DuckDuckGo is now your default search engine!
Thanks to Chris Wilson for the instructions.


19 x 15 mm SPDT Relay 3v - RL19S3
Summary
Name: 19 x 15 mm SPDT Relay 3v
ID: RELA-19X15-X-SPDT-VJ
Hex ID: RL19S3
WebPage: https://github.com/oomlout/oomlout-OOMP/wiki/RELA-19X15-X-SPDT-VJ
Short URL: http://oom.lt/RL19S3
Revision History: https://github.com/oomlout/oomlout-OOMP/blob/master/parts/RELA-19X15-X-SPDT-VJ/
| Type |
Size |
Color |
Description |
Index |
RELA Relay |
19X15 19 x 15 mm |
X
|
SPDT SPDT |
VJ 3v |
Images
About
This part is awaiting a description.
Specifications
| Info |
Value |
| Type |
Relay |
| Size |
19 x 15 mm |
| Description |
SPDT |
| Index |
3v |
| Width |
19 mm |
| Height |
15 mm |
Extra Details
Spotted a mistake, want to add more? Let us know<EMAIL_ADDRESS>All images and resources are licensed [CC BY-SA] unless otherwise stated (ie. the datasheets)


{% extends 'bridge/base.html' %} {% comment "License" %} % Copyright (c) 2019 ISP RAS (http://www.ispras.ru) % Ivannikov Institute for System Programming of the Russian Academy of Sciences % % Licensed under the Apache License, Version 2.0 (the "License"); % you may not use this file except in compliance with the License. % You may obtain a copy of the License at % % http://www.apache.org/licenses/LICENSE-2.0 % % Unless required by applicable law or agreed to in writing, software % distributed under the License is distributed on an "AS IS" BASIS, % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % See the License for the specific language governing permissions and % limitations under the License. {% endcomment %} {% load i18n %} {% load static %} {% load compress %} {% block head_block %} {# Calendar #} {% compress js file logs %} {% endcompress %} {% endblock %} {% block title %}{% trans 'Call logs' %}{% endblock %} {% block body_block %}


Poll Question Title
October 2014
Yes
No
Poll #2 Title
September 2014
Yes
No
Poll Q #3 Title
September 2014
Yes
No
Home
Back to Polls
Give us feedback


JSGen (Java Source Generation Framework)
Jsgen is a Java Source Generation Framework: That means, it should be a valuable tool, if you intend to write a custom generator for Java sources.
As such, it is the successor of a previous framework, called JaxMeJS. The predecessor came into being as a standalone project. It was incorporated into the bigger JaxMe project, when the latter was adopted by the Apache Webservices project. And it was buried as part of the bigger project, when the latter was moved to the Apache Attic.
That was fine for quite some time, because the latest released version (JaxMeJS 0.5.2) was still doing a decent job. Over the years, however, the Java language has evolved, and the lack of support for features like Generics, or Annotations, became a burden. Hence the Successor: Jsgen picks up, where JaxMeJS ended. It is, however, a complete rewrite with several additional features, that the author considers to be important for modern Java applications:
- It supports Generics.
- It supports Annotations.
- The builder pattern has been adopted. Almost all important classes are implemented as builders. This should make writing the actual source generators much more concise, and maintainable, than it used to be before.
- The code style is configurable. Code styles allow you to concentrate on the actual work. The resulting Jave source will look nicely formatted, anyways. As of this writing, you can select between two builtin code styles:
- The default code style is basically the authors personal free style, roughly comparable to the default code style of the Eclipse Java IDE.
- As an alternative, there is also a Maven code style, which is widely used in the Open Source communities. Compared to the default style, it is less concise, if not even a bit verbose. On the other hand, it is widely adopted by projects in the vicinity of Apache Maven.
- Import lists are created, and sorted, automatically.
Further reading:


|
|
CIFXOpenGLOS Class ReferenceInheritance diagram for CIFXOpenGLOS:
List of all members.
Constructor & Destructor Documentation
| CIFXOpenGLOS::CIFXOpenGLOS |
( |
|
) |
[protected] |
|
| virtual CIFXOpenGLOS::~CIFXOpenGLOS |
( |
|
) |
[inline, protected, virtual] |
|
| CIFXOpenGLOS::CIFXOpenGLOS |
( |
|
) |
[protected] |
|
| virtual CIFXOpenGLOS::~CIFXOpenGLOS |
( |
|
) |
[inline, protected, virtual] |
|
| CIFXOpenGLOS::CIFXOpenGLOS |
( |
|
) |
[protected] |
|
| virtual CIFXOpenGLOS::~CIFXOpenGLOS |
( |
|
) |
[inline, protected, virtual] |
|
Member Function Documentation
| U32 IFXAPI CIFXOpenGLOS::AddRef |
( |
|
) |
[virtual] |
|
|
|
This method increments the reference count for an interface on a component.
- Note:
- It should be called for every new copy of a pointer to an interface on a given component.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| U32 IFXAPI CIFXOpenGLOS::AddRef |
( |
|
) |
[virtual] |
|
|
|
This method increments the reference count for an interface on a component.
- Note:
- It should be called for every new copy of a pointer to an interface on a given component.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| U32 CIFXOpenGLOS::AddRef |
( |
|
) |
[virtual] |
|
|
|
This method increments the reference count for an interface on a component.
- Note:
- It should be called for every new copy of a pointer to an interface on a given component.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| IFXRESULT IFXAPI CIFXOpenGLOS::Construct |
( |
|
) |
[protected] |
|
| IFXRESULT IFXAPI CIFXOpenGLOS::Construct |
( |
|
) |
[protected] |
|
| IFXRESULT CIFXOpenGLOS::Construct |
( |
|
) |
[protected] |
|
| virtual IFXOGLPROC IFXAPI CIFXOpenGLOS::GetOGLExtensionFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| virtual IFXOGLPROC IFXAPI CIFXOpenGLOS::GetOGLExtensionFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| IFXOGLPROC IFXAPI CIFXOpenGLOS::GetOGLExtensionFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| virtual IFXOGLPROC IFXAPI CIFXOpenGLOS::GetOpenGLFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| virtual IFXOGLPROC IFXAPI CIFXOpenGLOS::GetOpenGLFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| IFXOGLPROC CIFXOpenGLOS::GetOpenGLFunc |
( |
char * |
szFuncName |
) |
[protected, virtual] |
|
| static CIFXOpenGLOS* CIFXOpenGLOS::GetSingleton |
( |
|
) |
[inline, static, protected] |
|
| static CIFXOpenGLOS* CIFXOpenGLOS::GetSingleton |
( |
|
) |
[inline, static, protected] |
|
| static CIFXOpenGLOS* CIFXOpenGLOS::GetSingleton |
( |
|
) |
[inline, static, protected] |
|
| IFXRESULT IFXAPI CIFXOpenGLOS::LoadExtensions |
( |
|
) |
[virtual] |
|
|
|
- Todo:
- : it is not right way to check 1.2 OpenGL version
Reimplemented from CIFXOpenGL. |
| IFXRESULT IFXAPI CIFXOpenGLOS::LoadExtensions |
( |
|
) |
[virtual] |
|
|
|
- Todo:
- : it is not right way to check 1.2 OpenGL version
Reimplemented from CIFXOpenGL. |
| IFXRESULT CIFXOpenGLOS::LoadExtensions |
( |
|
) |
[virtual] |
|
|
|
- Todo:
- : it is not right way to check 1.2 OpenGL version
Reimplemented from CIFXOpenGL. |
| virtual IFXRESULT IFXAPI CIFXOpenGLOS::LoadOpenGL |
( |
|
) |
[virtual] |
|
| virtual IFXRESULT IFXAPI CIFXOpenGLOS::LoadOpenGL |
( |
|
) |
[virtual] |
|
| IFXRESULT CIFXOpenGLOS::LoadOpenGL |
( |
|
) |
[virtual] |
|
| IFXRESULT IFXAPI CIFXOpenGLOS::LoadOSGL |
( |
|
) |
[virtual] |
|
|
|
Loads OS dependent OpenGL function pointers.
Most of these are in the agl, glX, or wgl family of functions.
Implements IFXOpenGL. |
| IFXRESULT IFXAPI CIFXOpenGLOS::LoadOSGL |
( |
|
) |
[virtual] |
|
|
|
Loads OS dependent OpenGL function pointers.
Most of these are in the agl, glX, or wgl family of functions.
Implements IFXOpenGL. |
| IFXRESULT CIFXOpenGLOS::LoadOSGL |
( |
|
) |
[virtual] |
|
|
|
Loads OS dependent OpenGL function pointers.
Most of these are in the agl, glX, or wgl family of functions.
Implements IFXOpenGL. |
| IFXRESULT IFXAPI CIFXOpenGLOS::QueryInterface |
( |
IFXREFIID |
interfaceId, |
|
|
void ** |
ppInterface |
|
) |
[virtual] |
|
|
|
This method provides access to the various interfaces supported by a component.
Upon success, it increments the component's reference count and hands back a pointer to the specified interface.
- Note:
- A number of rules must be adhered to by all implementations of IFXAPI QueryInterface . For a list of such rules, refer to the IFXCOM usage guidelines.
- Returns:
- Upon success, IFX_OK is returned. Otherwise, either IFX_E_INVALID_POINTER or IFX_E_UNSUPPORTED are returned.
Implements IFXUnknown. |
| IFXRESULT IFXAPI CIFXOpenGLOS::QueryInterface |
( |
IFXREFIID |
interfaceId, |
|
|
void ** |
ppInterface |
|
) |
[virtual] |
|
|
|
This method provides access to the various interfaces supported by a component.
Upon success, it increments the component's reference count and hands back a pointer to the specified interface.
- Note:
- A number of rules must be adhered to by all implementations of IFXAPI QueryInterface . For a list of such rules, refer to the IFXCOM usage guidelines.
- Returns:
- Upon success, IFX_OK is returned. Otherwise, either IFX_E_INVALID_POINTER or IFX_E_UNSUPPORTED are returned.
Implements IFXUnknown. |
| IFXRESULT CIFXOpenGLOS::QueryInterface |
( |
IFXREFIID |
interfaceId, |
|
|
void ** |
ppInterface |
|
) |
[virtual] |
|
|
|
This method provides access to the various interfaces supported by a component.
Upon success, it increments the component's reference count and hands back a pointer to the specified interface.
- Note:
- A number of rules must be adhered to by all implementations of IFXAPI QueryInterface . For a list of such rules, refer to the IFXCOM usage guidelines.
- Returns:
- Upon success, IFX_OK is returned. Otherwise, either IFX_E_INVALID_POINTER or IFX_E_UNSUPPORTED are returned.
Implements IFXUnknown. |
| U32 IFXAPI CIFXOpenGLOS::Release |
( |
|
) |
[virtual] |
|
|
|
This method decrements the reference count for the calling interface on a component.
- Note:
- If the reference count on a component falls to zero, the component is destroyed.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| U32 IFXAPI CIFXOpenGLOS::Release |
( |
|
) |
[virtual] |
|
|
|
This method decrements the reference count for the calling interface on a component.
- Note:
- If the reference count on a component falls to zero, the component is destroyed.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| U32 CIFXOpenGLOS::Release |
( |
|
) |
[virtual] |
|
|
|
This method decrements the reference count for the calling interface on a component.
- Note:
- If the reference count on a component falls to zero, the component is destroyed.
- Returns:
- It returns a U32 that contains a value from 1 to 2^32 - 1 that defines the new reference count. The return value should only be used for debugging purposes.
Implements IFXUnknown. |
| static void IFXAPI CIFXOpenGLOS::Shutdown |
( |
|
) |
[inline, static] |
|
| static void IFXAPI CIFXOpenGLOS::Shutdown |
( |
|
) |
[inline, static] |
|
| static void IFXAPI CIFXOpenGLOS::Shutdown |
( |
|
) |
[inline, static] |
|
| virtual IFXRESULT IFXAPI CIFXOpenGLOS::UnloadOpenGL |
( |
|
) |
[virtual] |
|
| virtual IFXRESULT IFXAPI CIFXOpenGLOS::UnloadOpenGL |
( |
|
) |
[virtual] |
|
| IFXRESULT CIFXOpenGLOS::UnloadOpenGL |
( |
|
) |
[virtual] |
|
Friends And Related Function Documentation
| IFXRESULT IFXAPI_CALLTYPE CIFXOpenGLOSFactory |
( |
IFXREFIID |
intId, |
|
|
void ** |
ppUnk |
|
) |
[friend] |
|
| IFXRESULT CIFXOpenGLOSFactory |
( |
IFXREFIID |
intId, |
|
|
void ** |
ppUnk |
|
) |
[friend] |
|
| IFXRESULT CIFXOpenGLOSFactory |
( |
IFXREFIID |
intId, |
|
|
void ** |
ppUnk |
|
) |
[friend] |
|
Member Data Documentation
© 1999 - 2006 Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
|
|


function Person(){} Person.prototype.dance = function(){}; function Ninja(){} Ninja.prototype = { dance: Person.prototype.dance }; var ninja = new Ninja(); assert(ninja instanceof Ninja, "ninja receives functionality from the Ninja prototype" ); assert( ninja instanceof Person, "... and the Person prototype" ); assert( ninja instanceof Object, "... and the Object prototype" ); #1 Defines a dancing Person #2 Defines a Ninja #3 Attempt to make a Ninja a Person Ninja.prototype = new Person(); is the correct inheritance Make sure not to use the Ninja.prototype = Person.prototype; When doing this, any changes to the Ninja prototype will also change the Person prototype (since they're the same object) – which is bound to have undesirable side effects.


Just over 100 years ago, manual transmissions were the only option for drivers until the Sturtevant brothers of Boston attempted the first automatic transmission in 1904.
A new era of F1 is on the horizon with the championship set to tweak its rulebook next(or next to next) year. A bold new vision for the future of F1 has been unveiled.
The whole world is everchanging and so is the automobile industry. With different technologies making cars both more fun and safer to drive, attention is also being paid to make automobiles greener and thus safer for the environment.
If we roll back a few years, people had very narrow options when it came to choosing a car with 4 driven wheels. It was mainly centered at trucks or large SUVs. In India, one such car was Maruti Suzuki Gypsy
When we read this term, the first thing that comes to our mind is entry-level budget cars. And it’s not wrong to be thinking that way as 3-cylinder engines were mainly used in the low budget entry-level cars like Maruti Suzuki Alto. But the present scenario is the stark opposite.


At First Sight (Reviewed on Feb. 5/99)
Starring Val Kilmer, Mira Sorvino, Nathan Lane
What must it be like to be blind? Never being able to physically see anything, always touching for some semblance of that sensation. I respect blind people just because they're able to get through every single day despite such a huge hurdle to overcome.
In "At First Sight", Val Kilmer plays such a person. Blind since the age of three, he's just as competent as anyone else, provided he's familiar with his surroundings. He's employed as a masseuse at the local spa, he has lots of friends, and a sister who loves him and cares for him.  They fall in love, and she changes his life. She moves him to New York and introduces him to a doctor who promises him his sight through a radical new operation. He accepts, and finds himself thrust into the world of the seeing. Nathan Lane enters the picture as a "sight therapist" who helps Kilmer understand what he's seeing.
"At First Sight" contains the restoration of sight to a blind man, but is more interested in the romance between Kilmer and Sorvino. And that's the major flaw of the movie. Not that Kilmer and Sorvino don't make an enjoyable and engaging couple; in fact, their chemistry is instantly believable.
No, the problem with "At First Sight" is that the filmmakers seem to think that we would prefer to witness endless scenes of Kilmer and Sorvino frolicking in parks, ice rinks, etc. I found the concept of restoring vision to a blind man to be fascinating, and was quite disappointed to come to the realization, around an hour into the movie, that Kilmer and Sorvino's romance was going to dominate the film.
Not nearly enough time is spent on Kilmer's adjustment to sight. I'd say it takes him about 15 minutes of screen time to get acclimitized to the world of the seeing. I would have liked to have seen a lot more of this process, and I especially would have liked to have seen more Nathan Lane. He's the stand-out here, and it's too bad that his part is such a minor element of the movie.
"At First Sight" isn't a bad movie by any means. It's just a disappointing one.
** out of ****
-- David Nusair http://www.reelfilm.com
"I like your nurses uniform, guy." | "These are O.R. scrubs." | THIS SPACE FOR RENT "Oh, are they?" | --Rushmore-- |
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The Schedule:
Saturday 11th
- 0900 Doors open
- 1100 Opening ceremony
- 1200 Hacking begins
- 1300 Lunch 1
- 1400 Workshop 1 - Discord Bots (Python)
- 1500 Workshop 2 - Frasers
- 1600 Workshop 3 - Frasers
- 1700 Workshop 4 - Capital One
- 1830 Pizza time
- 1900 Werewolf
- 1930 Hungernite MC server opens
- 2000 Sleeping area available
Sunday 12th
- 0000 Midnight Doughnotts
- 0730 Breakfast
- 1200 Devpost closes & hacking stops
- 1200 Lunch 2
- 1245 Judging starts - science fair style
- 1430 Judging stops
- 1445 Closing ceremony
- 1600 Predicted finish
Note: this schedule is subject to change


Comments
-
Alexei Danchenkov
Update: 2. segfault crash is not specific to Command-T. It also crashes with kien's ctrlp, lusty explorer and even vim's default :e. It is apparently Windows8's bugs.
-
Greg Hurrell
For keybinding help, see this blog post. Getting the mappings all working properly under different terminals can require a little bit of customization.
For the Windows issues, I'm afraid I don't have much knowledge about that. The general base rule of ensuring that Vim and Command-T get compiled/linked against the same version of Ruby is really the only advice I have.
-
Greg Hurrell
Closing due to lack of activity.
-
Greg Hurrell
Status changed:
- From: new
- To: closed
Add a comment
Comments are now closed for this issue.