React native wrapper for 100ms SDK
npm install react-native-hms
cd ios/ && pod install
📲 Download the Sample iOS App here: https://testflight.apple.com/join/v4bSIPad
🤖 Download the Sample Android App here: https://appdistribution.firebase.dev/i/7b7ab3b30e627c35
Add following permissions in info.plist file
<key>NSLocalNetworkUsageDescription</key>
<string>{YourAppName} App wants to use your local network</string>
<key>NSMicrophoneUsageDescription</key>
<string>{YourAppName} wants to use your microphone</string>
<key>NSCameraUsageDescription</key>
<string>{YourAppName} wants to use your camera</string>
The package exports four Classes and an HMSManager class that manages everything.
first we'll have to call build method, that method returns an instance of HMSManager class and the same is used to perform all the operations
import HmsManager from 'react-native-hms';
...
const hmsInstance = await HmsManager.build();
//save this instance, will be used for all the operations that we'll perform
...
add event listeners for all the events such as onPreview, onJoin, onPeerUpdate etc. the actions can be found in HMSUpdateListenerActions class
import HmsManager, {
HMSUpdateListenerActions,
} from 'react-native-hms';
...
// instance acquired from build() method
hmsInstance.addEventListener(
HMSUpdateListenerActions.ON_PREVIEW,
previewSuccess, // function that will be called on Preview success
);
...
The event handlers are the way of handling any update happening in hms all events can be found in HMSUpdateListenerActions class
Joining the room connects you to the remote peer and broadcasts your stream to other peers, we need instance of HMSConfig in order to pass the details of room and user to join function
import HmsManager, {
HMSUpdateListenerActions,
HMSConfig,
} from 'react-native-hms';
...
// instance acquired from build() method
const HmsConfig = new HMSConfig({authToken, userID, roomID});
instance.preview(HmsConfig); // to start preview
// or
instance.join(HmsConfig); // to join a room
...
don't forget to add ON_JOIN listener before calling join to receive an event callback
To display a video on screen the package provide a UI component named HmsView that takes the video track ID and displays the video in that component, this component requires on width and height in style prop to set bounds of the tile that will show the video stream
...
//getting local track ID
const localTrackId = instance?.localPeer?.videoTrack?.trackId;
// getting remote track IDs
const remotePeers = instance?.remotePeers
const remoteVideoIds: string[] = [];
remotePeers.map((remotePeer: any) => {
const remoteTrackId = remotePeer?.videoTrack?.trackId;
if (remoteTrackId) {
remoteVideoIds.push(remoteTrackId);
}
});
...
import { HmsView } from 'react-native-hms';
...
const styles = StyleSheet.create({
hmsView: {
height: '100%',
width: '100%',
},
});
// trackId can be acquired from the method explained above
<HmsView style={styles.hmsView} trackId={trackId} />
...
// Mute Audio
instance.localPeer.localAudioTrack().setMute(isMute);
// Stop Video
instance.localPeer.localVideoTrack().setMute(muteVideo);
// Switch Camera
instance.localPeer.localVideoTrack().switchCamera();
// Leave the call
instance.leave()
import { HMSMessage } from '@100mslive/react-native-hms';
// message object
const message = new HMSMessage({
type: 'chat',
time: new Date().toISOString(),
message: value,
});
// send a message
instance.send(message);
// import actions
import { HMSUpdateListenerActions } from '@100mslive/react-native-hms';
// add a event listener
instance.addEventListener(HMSUpdateListenerActions.ON_ERROR, onError);
Generated using TypeDoc


A friend and a shoulder to rely on
I was suffering from a personal problem since a long time. As the day passed it was getting tougher for me to overcome my problem despite taking help from the friends. It was then I decided to take help the consultant. Initially I was too hesitant to take the help as I thought consulting is only for the losers and people who are mentally challenged and me being an IIT-ian, it will be against my pride to take help of some consultant, but I had no other option left and thought let’s give this a try. To my surprise, it was an overall good experience for me. It helped me a lot.Changed perspective
I went into depression and anxiety disorder just before coming to IIIT Kota. When I reached IIIT, I was not able to concentrate on my studies.  After a few months I came to know about the student counsellors in IIIT Kota through my Professor. The Professor arranged a meeting with Mrs. Hima Anaredy, a student counselor of IIIT Kota. Initially I was hesitant to meet a stranger and tell him/her that I need help. But then I had already reached a stage where I wanted to vent out my emotions which I was not able to handle by myself.


Folders
<Go Back>
app
gradle
File
File
File
File
gradlew
build.gradle
ReactNati...or.iml
gradle.properties
gradlew.bat
settings.gradle
Folders: 3
Files: 6
Size of all files: 10044 KB


Goal
To create awesome User Interfaces that I cannot wait to share with the world.
Experience
Software Engineer August 2013 - Present
Cisco Systems, Full-Time
Working in the Connected Mobile eXperiences (CMX) team which develops applications leveraging indoor location information provided by Cisco. Created the UI for CMX Connect, the guest access solution for CMX.
Technologies used: Backbone with Marionette (MV*), Less (Css), Html, Javascript/jQuery/jQueryMobile, Hellojs (OAuth 2.0), Highcharts, and Jasmine (UT).
Custom Guest Portal
- Created the Guest Portal Designer, a WYSIWYG editor which allows non-technical venue owners to design and serve responsive splash pages to their customers. Venue owners can upload their own branding content, such as images and terms, and collect guest information using registration forms or Social OAuth.
- Developed the Custom Splash Page that is served to visitors. Worked to provide cross-browser support for browsers ranging back to Internet Explorer 8 and also cross-device support for phones to tablets and PCs.
Facebook Wi-Fi
- Created UI for Facebook Wi-Fi, a guest Wi-Fi product offered by Cisco and Facebook which allows guests to onboard to Wi-Fi by checking-in to a venue's page with their Facebook account.
Reporting and Configuration
- Designed and implemented reporting dashboard for CMX Connect. Reports shown includes location-specific, guest-trend KPIs and data charts using highcharts.
- Built the configurations page where venue owners can assign portals and/or Facebook Wi-Fi pages to their venues. Designed an inheritance-based pairing scheme which allowed venue owners to reuse pairings, greatly reducing the number of locations they had to set up pairings for.
Skills
- Backbone with Marionette
- Javascript, Html/Html5, Css/Css3
- jQuery/jQueryMobile, Bootstrap, Hellojs, Highcharts, Less, and Jasmine
- Responsive Web Designs
- Git, SVN, and Linux
- Java
- Agile Development
Education
University of California, Berkeley May, 2013
Bachelor, Computer Science
Projects
Groceroo Fall, 2013
A collaborative grocery shopping webapp
Worked with 4 other classmates in a semester long UI design project.
- Continuously refined interface designs through iterations of the Design-Prototype-Evaluate cycle.
- Developed a functional prototype using Javascript, Css, and Twitter Bootstrap.
- Project chosen as one of top three in class by Google UI/UX engineers.
CrowdPhotoEditor Spring, 2012
A crowdsourced photo-editing SaaS webapp
Collaborated with 3 other classmates in a semester long app development project.
- Worked with non-technical client from planning and development through testing, assessment, and deployment.
- Practiced Agile development concepts and tools such as scrum and pair-programming in 2 week iterations.
- Was one of three groups chosen to present project to billionare CEO of C3 Energy, Tom Siebel.


App Feature One
Outline an app feature/benefit here. You can change the icon above to any of the 500+FontAwesome icons available.
{extend name="base"/} {block name="con"}
Outline an app feature/benefit here. You can change the icon above to any of the 500+FontAwesome icons available.
Outline an app feature/benefit here. You can change the icon above to any of the 500+FontAwesome icons available.
Outline an app feature/benefit here. You can change the icon above to any of the 500+FontAwesome icons available.
Outline an app feature/benefit here. You can change the icon above to any of the 500+FontAwesome icons available.
{$v.anser}
{$v.anser}


Class: Sketchup::Layer
| Relationships | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Entity
|
|
|
Instance Chain:
self,
Comparable,
Entity
|
|
| Inherits: |
Sketchup::Entity
|
Overview
As of SketchUp 2020 “Layers” were renamed to “Tags” in the ::UI
. The API retains the use of “Layer” for compatibility and is synonymous with “Tag”.
The Layer class contains methods modifying and extracting information for a layer.
By default, a SketchUp model has one layer, Layer
0 (Named “Untagged” in the ::UI
since SketchUp 2020), which is the base layer. You can’t delete or rename Layer
0. Unlike certain other CAD software packages, entities associated with different layers in SketchUp still intersect with each other. (If you want collections of entities to not intersect, place them in Groups instead.)
Layers
are commonly used to organize your model and control the visibility of related groups and components. For example, you could make all of your wall and roof entities different groups, associate layers with those groups, and then hide those layers so as to display just the floor plan in the model.
Instance Attribute Summary
-
#color ⇒ Sketchup::Color
rw
The #color method is used to retrieve the color of the layer.
-
#color=(color)
rw
The #color= method is used to set the name of a layer.
-
#folder ⇒ Sketchup::LayerFolder?
rw
The #folder method is used to return the parent layer folder of a layer.
-
#folder=(parent)
rw
The #folder= method is used to set the parent layer folder of a layer.
-
#line_style ⇒ Sketchup::LineStyle?
rw
The #line_style method retrieves the line style on this layer.
-
#line_style=(line_style) ⇒ Sketchup::Layer
rw
The #line_style= method lets you set a specific line style to a layer.
-
#name ⇒ String
rw
The #name method is used to retrieve the name of the layer.
-
#name=(name)
rw
The #name= method is used to set the name of a layer.
-
#page_behavior ⇒ Integer
rw
The #page_behavior method is used to retrieve the visibility behavior of the layer for new pages and existing pages.
-
#page_behavior=(page_behavior)
rw
The #page_behavior= method is used to control the layer’s visibility behavior on existing and new pages.
-
#visible=(visible)
rw
The #visible= method is used to set if the layer is visible.
-
#visible? ⇒ Boolean
rw
The #visible? method is used to determine if the layer is visible.
Entity
- Inherited
Instance Method Summary
-
#<=>(layer2) ⇒ Integer
The #<=> method is used to compare two layers based on their names.
-
#==(other)
The #== method is used to determine if two layers are the same.
-
#display_name ⇒ String
The #display_name method is used to retrieve the display name of the layer.
Entity
- Inherited
| #add_observer | The add_observer method is used to add an observer to the current object. |
| #attribute_dictionaries | The attribute_dictionaries method is used to retrieve the |
| #attribute_dictionary | The attribute_dictionary method is used to retrieve an attribute dictionary with a given name that is attached to an |
| #delete_attribute | The |
| #entityID | The entityID method is used to retrieve a unique ID assigned to an entity. |
| #get_attribute | The |
| #inspect | The to_s method is used to retrieve the string representation of the entity. |
| #model | The model method is used to retrieve the model for the entity. |
| #parent | The parent method is used to retrieve the parent of the entity. |
| #persistent_id | The |
| #remove_observer | The remove_observer method is used to remove an observer from the current object. |
| #set_attribute | The set attribute is used to set the value of an attribute in an attribute dictionary with the given name. |
| #to_s | The to_s method is used to retrieve the string representation of the entity. |
| #typename | The typename method retrieves the type of the entity, which will be a string such as “Face”, “Edge”, or “Group”. |
Instance Attribute Details
#color ⇒ Sketchup::Color (rw)
The #color
method is used to retrieve the color of the layer.
#color=(color) (rw)
The #color=
method is used to set the name of a layer.
#folder ⇒ Sketchup::LayerFolder? (rw)
The #folder
method is used to return the parent layer folder of a layer.
#folder=(parent) (rw)
The #folder=
method is used to set the parent layer folder of a layer.
This will trigger onParentFolderChanged
in normal cases and onLayerChanged
during undo/redo.
#line_style ⇒ Sketchup::LineStyle? (rw)
The #line_style
method retrieves the line style on this layer.
#line_style=(line_style) ⇒ Layer
(rw)
The #line_style=
method lets you set a specific line style to a layer
#name ⇒ String (rw)
The #name
method is used to retrieve the name of the layer.
#name=(name) (rw)
The #name=
method is used to set the name of a layer.
#page_behavior ⇒ Integer
(rw)
The #page_behavior
method is used to retrieve the visibility behavior of the layer for new pages and existing pages. For example, you may want your layer to be visible or hidden by default in any new pages (aka Scenes) created by the user.
A page keeps a list of layers that do not have their default behavior. If a layer is not in that list, then it is set to its default visibility determined by one of these values:
The behaviour is composed of a combination of these flags:
- Default visibility
-
These flags are used to set the value of
#page_behavior
. A page keeps a list of layers that do not have their default behavior. If a layer is not in that list, then it is set to its default visibility which is determined by one of these flags.-
LAYER_VISIBLE_BY_DEFAULT:
0x0000
-
LAYER_HIDDEN_BY_DEFAULT:
0x0001
-
- Visibility on new pages
-
You can also set this addition flag that controls the visibility of a layer on newly created pages.
-
LAYER_IS_VISIBLE_ON_NEW_PAGES:
0x0010
-
LAYER_IS_HIDDEN_ON_NEW_PAGES:
0x0020
The default visibility for a layer is set by either LAYER_VISIBLE_BY_DEFAULT or LAYER_HIDDEN_BY_DEFAULT. This is what will be used when a page does not contain the visibility state of a layer.
The remaining flags control the visibility of the layer for new pages.
#page_behavior=(page_behavior) (rw)
The #page_behavior=
method is used to control the layer’s visibility behavior on existing and new pages.
When you Update a page (as opposed to creating a new page) the current visibility of the layer is used.
The behavior is composed of a combination of these flags:
- Default visibility
-
These flags are used to set the value of #page_behavior. A page keeps a list of layers that do not have their default behavior. If a layer is not in that list, then it is set to its default visibility which is determined by one of these flags.
-
LAYER_VISIBLE_BY_DEFAULT:
0x0000
-
LAYER_HIDDEN_BY_DEFAULT:
0x0001
-
- Visibility on new pages
-
You can also set this addition flag that controls the visibility of a layer on newly created pages.
-
LAYER_IS_VISIBLE_ON_NEW_PAGES:
0x0010
-
LAYER_IS_HIDDEN_ON_NEW_PAGES:
0x0020
#visible=(visible) (rw)
The #visible=
method is used to set if the layer is visible.
#visible? ⇒ Boolean
(rw)
The #visible?
method is used to determine if the layer is visible.
Instance Method Details
#<=>(layer2) ⇒ Integer
The #<=>
method is used to compare two layers based on their names. This enables the Ruby Array#sort method to sort SketchUp layers.
#==(other)
The #==
method is used to determine if two layers are the same.
#display_name ⇒ String
The #display_name
method is used to retrieve the display name of the layer.


Hi! My name is Iñigo and I’m a research scientist in machine learning.
I have a background working with large and varied datasets and using advanced statistical methods. I transform data into valuable and tangible insights through data science techniques, machine learning and visualization.
My research focus & areas of interest
Experience
Vicomtech Research Center
Data Intelligence for Energy and Industrial Processes
PhD, Data Scientist
Jun. 2019 - Present
Education
University of Navarra - Tecnun School of Engineering
San Sebastian, Spain
Ph.D. in Applied Engineering, Computer Science
Mar. 2018 - Expected graduation Sep. 2022
Master of Science in Industrial (Mechanical) Engineering
Sep. 2015 - Jul. 2017
Bachelor of Science in Industrial Technologies
Sep. 2011 - May. 2015
Skills
Languages
R
Python
Julia
C++
CUDA
Matlab
Java
SQL
Data Science
PyTorch
Tensorflow
Keras
Scikit-Learn
Numpy
Scipy
Pandas
Tidyverse
Web Dev
Javascript
React
Vue
Node
Webpack
Jekyll
Tailwind
Shiny
Graphics
Adobe CC
Inkscape
TikZ
ggplot2
matplotlib
Processing
p5
WebGL
Simulation
Simpy
GAMA
Simulink
Unity
Maps
QGIS
Mapbox
Leaflet
deck.gl
Fabrication
Additive manufacturing
Laser cutting
Waterjet
CNC machining
CAD CAE
Solidworks
PTC Creo
AutoCAD
ANSYS


Times New Roman is a serif font. It is the default for most web browsers.
Arial is a sans-serif font that is widely used, and sans-serif fonts are best for web pages.
Courier New is a monospace font that is used for code examples.
Lucida Handwriting is a cursive font that is not frequently used.
Impact is a fantasy font that is rarely used.


Home
About Us
Gift Giving Experiences
Giving
Stories of Receiving
Gift Giving
Photos
How Can I Participate
Volunteering Time
Event Hosting
Churches
Schools
GGA Wishlist
Gifting Projects
Donations
Gifting All-Year-Long
Christmas Giving Project
Kindness Ideas
Contact Us
E-mail Kalei Heartland:
<EMAIL_ADDRESS>Questions, inquries, requests, comments? We'd love to hear from you!
First Name:
Last Name:
E-mail:
Comment:
Statement on Personal Data Protection: Gift Givers Anonymous does
not
share any contact information with third parties.


| Name | Cuisine | Neighborhood | Lunch | Dinner |
|---|---|---|---|---|
| {{ result.name }} | {{ result.cuisine }} | {{ result.neighborhood }} | {{ result.lunch_price }} | {{ result.dinner_price }} |
| Name | Cuisine | Neighborhood | Lunch | Dinner |
|---|---|---|---|---|
| {{ result.name }} | {{ result.cuisine }} | {{ result.neighborhood }} | {{ result.lunch_price }} | {{ result.dinner_price }} |


Unfortunately, Google and Facebook has closed their API services. Word Cloud can no longer access your data without these services.
In the meantime, you could supply text or file directly on the left.
Imgur
Facebook
Tumblr
Twitter
Plurk
—


iOS Security Whitepaper
This is a summary of the iOS security whitepaper.
System Security
Secure boot chain
Each step of the startup process contains components that are cryptographically signed by Apple to ensure integrity and that proceed only after verifying the chain of trust.
System Software Authorization
-
To prevent devices from being downgraded to older versions that lack the latest security updates, iOS uses a process called System Software Authorization.
-
During an iOS upgrade, iTunes (or the device itself, in the case of OTA software updates) connects to the Apple installation authorization server and sends it a list of cryptographic measurements for each part of the installation bundle to be installed (for example, iBoot, the kernel, and OS image), a random anti-replay value (nonce), and the device’s unique ID (ECID).
-
The authorization server checks the presented list of measurements against versions for which installation is permitted and, if it finds a match, adds the ECID to the measurement and signs the result. The server passes a complete set of signed data to the device as part of the upgrade process. Adding the ECID “personalizes” the authorization for the requesting device. By authorizing and signing only for known measurements, the server ensures that the update takes place exactly as provided by Apple
Secure Enclave
-
The Secure Enclave is a coprocessor fabricated in the Apple S2, Apple A7, and later A-series processors
-
Provides all cryptographic operations for Data Protection key management and maintains the integrity of Data Protection even if the kernel has been compromised
-
Additionally, data that is saved to the file system by the Secure Enclave is encrypted with a key entangled with the UID and an anti-replay counter
-
The Secure Enclave is responsible for processing fingerprint data from the Touch ID sensor, determining if there is a match against registered fingerprints, and then enabling access or purchases on behalf of the user
TouchId
-
The fingerprint sensor is active only when the capacitive steel ring that surrounds the Home button detects the touch of a finger, which triggers the advanced imaging array to scan the finger and send the scan to the Secure Enclave.
-
The resulting map of nodes is stored without any identity information in an encrypted format that can only be read by the Secure Enclave, and is never sent to Apple or backed up to iCloud or iTunes
File Data Protection
Overview
-
Every time a file on the data partition is created, Data Protection creates a new 256-bit key (the “per-file” key) and gives it to the hardware AES engine, which uses the key to encrypt the file as it is written to flash memory using AES CBC mode.
-
The content of a file is encrypted with a per-file key, which is wrapped with a class key and stored in a file’s metadata, which is in turn encrypted with the file system key.
Passcode
-
By setting up a device passcode, the user automatically enables Data Protection.
-
The passcode is entangled with the device’s UID, so brute-force attempts must be performed on the device under attack.
-
A large iteration count is used to make each attempt slower.
Data Protection classes
-
Complete Protection - NSFileProtectionComplete
-
Shortly after the user locks a device (10 seconds, if the Require Password setting is Immediately), the decrypted class key is discarded, rendering all data in this class inaccessible until the user enters the passcode again or unlocks the device using Touch ID
-
-
Protected Unless Open - NSFileProtectionCompleteUnlessOpen
-
To protect files that need to be written while the device is locked
-
-
Protected Until First User Authentication - NSFileProtectionCompleteUntilFirstUserAuthentication
-
This class behaves in the same way as Complete Protection, except that the decrypted class key isn’t removed from memory when the device is locked
-
This is the default class for all third-party app data not otherwise assigned to a Data Protection class
-
-
No Protection - NSFileProtectionNone
Keychain Data Protection
-
The Keychain is implemented as a SQLite database stored on the file system.
-
Keychain items can only be shared between apps from the same developer.
-
Keychain data is protected using a class structure similar to the one used in file Data Protection.
-
When unlocked - kSecAttrAccessibleWhenUnlocked
-
While locked - N/A
-
After first unlock - kSecAttrAccessibleAfterFirstUnlock
-
Always - kSecAttrAccessibleAlways
-
Passcode Enabled - kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly
-
-
Keychain classes have a “This device only” counterpart, which is always protected with the UID when being copied from the device during a backup, rendering it useless if restored to a different device
-
Keychains can use access control lists (ACLs) to set policies for accessibility and authentication requirements
Access to Safari saved passwords
-
iOS apps can interact with Keychain items saved by Safari for password autofill using the following two APIs:
-
SecRequestSharedWebCredential
-
SecAddSharedWebCredential
-
-
Access will be granted only if both the app developer and website administrator have given their approval, and the user has given consent.
Keybags
-
The keys for both file and Keychain Data Protection classes are collected and managed in keybags.
-
iOS uses the following keybags:
-
user
-
Is where the wrapped class keys used in normal operation of the device are stored.
-
-
device
-
Is used to store the wrapped class keys used for operations involving device-specific data
-
On iOS devices configured for use by a single user (the default configuration), the device keybag and the user keybag are one and the same, and are protected by the user’s passcode
-
-
backup
-
Is created when an encrypted backup is made by iTunes and stored on the computer to which the device is backed up
-
If a user chooses not to encrypt an iTunes backup, the backup files aren’t encrypted regardless of their Data Protection class, but the Keychain remains protected with a UID-derived key.
-
-
escrow
-
Is used for iTunes syncing and MDM, allows iTunes to back up and sync without requiring the user to enter a passcode, and it allows an MDM server to remotely clear a user’s passcode.
-
-
iCloud Backup
-
Is similar to the backup keybag
-
-
App Security
App code signing
-
To ensure that all apps come from a known and approved source and haven’t been tampered with, iOS requires that all executable code be signed using an Apple-issued certificate
-
To protect the system and other apps from loading third-party code inside of their address space, the system will perform a code signature validation of all the dynamic libraries that a process links against at launch time.
-
At runtime, code signature checks of all executable memory pages are made as they are loaded to ensure that an app has not been modified since it was installed or last updated
Runtime process security
-
All third-party apps are “sandboxed,” so they are restricted from accessing files stored by other apps or from making changes to the device.
-
System files and resources are also shielded from the user’s apps. The majority of iOS runs as the non-privileged user “mobile,” as do all third-party apps.
-
Access by third-party apps to user information and features such as iCloud and extensibility is controlled using declared entitlements.
-
Address space layout randomization (ASLR) protects against the exploitation of memory corruption bugs.
-
Further protection is provided by iOS using ARM’s Execute Never (XN) feature, which marks memory pages as non-executable.
Extensions
-
Extensions are special-purpose signed executable binaries, packaged within an app.
-
The system automatically launches extension processes as needed and manages their lifetime.
-
Extensions run in their own address space. Communication between the extension and the app from which it was activated uses interprocess communications mediated by the system framework. They don’t have access to each other’s files or memory spaces.
-
Extensions are designed to be isolated from each other, from their containing apps, and from the apps that use them.
-
Custom keyboards are a special type of extension
-
A keyboard extension will be used for any text field except the passcode input and any secure text view
-
To restrict the transfer of user data, custom keyboards run by default in a very restrictive sandbox that blocks access to the network, to services that perform network operations on behalf of a process, and to APIs that would allow the extension to exfiltrate typing data.
-
App Groups
-
Apps and extensions owned by a given developer account can share content when configured to be part of an App Group.
-
Once configured to be part of an App Group, apps have access to the following:
-
A shared on-disk container for storage, which will stay on the device as long as at least one app from the group is installed
-
Shared preferences
-
Shared Keychain items
-
Data Protection in apps
-
Data Protection is available for file and database APIs, including NSFileManager, CoreData, NSData, and SQLite
-
User-installed apps that don’t opt-in to a specific Data Protection class receive Protected Until First User Authentication by default.
Accessories
-
When an MFi accessory communicates with an iOS device using a Lightning connector or via Bluetooth, the device asks the accessory to prove it has been authorized by Apple by responding with an Apple-provided certificate, which is verified by the device.
-
The device then sends a challenge, which the accessory must answer with a signed response.
-
This process is entirely handled by a custom integrated circuit that Apple provides to approved accessory manufacturers and is transparent to the accessory itself
Homekit
-
This stored data is encrypted using keys derived from the user’s HomeKit identity keys, plus a random nonce.
-
Additionally, HomeKit data is stored using Data Protection class Protected Until First User Authentication.
-
Is only backed up in encrypted backups, so, for example, unencrypted iTunes backups don’t contain HomeKit data
-
Data synchronization
-
The HomeKit data is encrypted during the synchronization using keys derived from the user’s HomeKit identity and random nonce.
-
HealthKit
-
User’s health data is stored in Data Protection class Complete Protection, which means it is accessible only after a user enters their passcode or uses Touch ID to unlock the device
-
Management data is stored in Data Protection class Protected Until First User Authentication
-
Temporary journal files store health records are stored in Data Protection class Protected Unless Open.
-
Isn’t synced between devices, is included in device backups to iCloud and encrypted iTunes backups
Network Security
TLS
-
iOS supports Transport Layer Security (TLS v1.0, TLS v1.1, and TLS v1.2, which supports both AES 128 and SHA-2) and DTLS
-
CFNetwork disallows SSLv3, and apps that use WebKit (such as Safari) are prohibited from making an SSLv3 connection
-
The RC4 symmetric cipher suite is deprecated in iOS 10 and macOS Sierra
-
App Transport Security
-
provides default connection requirements so that apps adhere to best practices for secure connections when using NSURLConnection, CFURL, or NSURLSession APIs
-
VPN
-
iOS supports VPN On Demand for networks that use certificate-based authentication.
-
iOS also supports Per App VPN support, facilitating VPN connections on a much more granular basis.
-
iOS supports Always-on VPN, which can be configured for devices managed via MDM and supervised using Apple Configurator or the Device Enrollment Program.
Single Sign-on
-
iOS supports authentication to enterprise networks through Single Sign-on (SSO).
-
SSO works with Kerberos-based networks to authenticate users to services they are authorized to access.
-
To configure SSO, iOS supports a configuration profile payload that allows MDM servers to push down the necessary settings.


DAMAGE A film review by Ken Johnson Copyright 1993 Ken Johnson
1:54, unrated version (NC-17 version), Drama, 1993 Director: Louis Malle Cast: Jeremy Irons, Juliette Binoche, Miranda Richardson, Rupert Graves, Ian Bannen, Peter Stormare, Gemma Clarke, Julian Fellowes, Leslie Caron
Jeremy Irons is having an obsessive affair with Juliette Binoche. Binoche falls in love with Rupert Graves, Irons's son. As Binoche and Graves relationship gets more and more serious, Irons tries to end it.
DAMAGE is an incredibly slow-moving boring film that is a complete waste of time. I can't recommend this film to anyone, unless you enjoy watching grass grow in the dark. DAMAGE is now available on videocassette in two versions, the R rated theatrical version that runs for 1:50 and the unrated (original NC-17 version) that runs for 1:54 (the version that I am reviewing). On a scale of zero to five, I give DAMAGE a zero (too bad it doesn't go lower). DAMAGE is unrated and contains female nudity, brief male nudity, adult situations, and explicit language.
Louis Malle, the director of the good film PRETTY BABY, has made a real loser of a film. Hopefully this film will be a low point in his career. Jeremy Irons (whom I have heard is a good actor) was not at all impressive in this film. The only way to describe his acting is wooden and uninspired. Juliette Binoche (a newcomer to films I believe) also didn't do a good job. She didn't ever seem to be with this film. Miranda Richardson (who did such a good job in the recent THE CRYING GAME) is not at all interesting in this film. I was very disappointed, especially considering she received an academy award nomination for best supporting actress. Rupert Graves (WHERE ANGELS FEAR TO TREAD) does the best job out of the cast. He seemed to put some life into his role.
This film is poorly written and moves along slowly. The characters are boring and invoke no interest from the viewer. I have something to say about the "hot and steamy" sex scenes too, they were neither hot or steamy. Jeremy Irons and Juliette Binoche have about as much sexual chemistry as two eggs.  If you are looking for a good erotic drama, may I suggest THE BLUE LAGOON with Brooke Shields and Christopher Atkins or WILD ORCHID with Mickey Rourke and Carre Otis. And if you are looking for a well done film, may I suggest that you just skip this one.
-------- Ken Johnson<EMAIL_ADDRESS>.
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 ACME Corporation provides outstanding products to help you acheive your dreams. Whether they be outsmarting a high-strung bird or seeking revenge on an asinine Earth creature, ACME is here to help!
Our customer service is second to none. Simply fill out our order form and mail. Within seconds, you'll have your very own ACME product delivered right to your location.
Contact us!
1-800-888-ACME


We can do best of bread documentaries on any theme.
We are able to make fantastic software on demand.
We are able to make prototypes of small electronic devices.
We can deliver uniqe product of your design.


{% extends "base.html" %}
{% load app_filters %}
{% block title %}Upload CSV File{% endblock %}
{% block sidebar_admin_import %}active{% endblock %}
{% block body_header %}
Download CSV file
Upload CSV
{% endblock %}
{% block body %}
Select a type of file and click '{{ form_button }}' to download.
{% include "singleform.html" %}


| Package | Description |
|---|---|
| it.unimi.dsi.fastutil.bytes |
Provides type-specific classes for byte elements or keys.
|
| it.unimi.dsi.fastutil.chars |
Provides type-specific classes for character elements or keys.
|
| it.unimi.dsi.fastutil.doubles |
Provides type-specific classes for double elements or keys.
|
| it.unimi.dsi.fastutil.floats |
Provides type-specific classes for float elements or keys.
|
| it.unimi.dsi.fastutil.ints |
Provides type-specific classes for integer elements or keys.
|
| it.unimi.dsi.fastutil.io |
Provides classes and static methods that make object and primitive-type I/O easier and faster.
|
| it.unimi.dsi.fastutil.longs |
Provides type-specific classes for long elements or keys.
|
| it.unimi.dsi.fastutil.objects |
Provides type-specific classes for object elements or keys.
|
| it.unimi.dsi.fastutil.shorts |
Provides type-specific classes for short elements or keys.
|
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| Class and Description |
|---|
| AbstractShort2BooleanFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2BooleanMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2BooleanSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ByteFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ByteMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ByteSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2CharFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2CharMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2CharSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2DoubleFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2DoubleMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2DoubleSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2FloatFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2FloatMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2FloatSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2IntFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2IntMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2IntSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2LongFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2LongMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2LongSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ObjectFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ObjectMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ObjectSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ReferenceFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ReferenceMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ReferenceSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShort2ShortFunction
An abstract class providing basic methods for functions implementing a type-specific interface.
|
| AbstractShort2ShortMap
An abstract class providing basic methods for maps implementing a type-specific interface.
|
| AbstractShort2ShortSortedMap
An abstract class providing basic methods for sorted maps implementing a type-specific interface.
|
| AbstractShortBidirectionalIterator
An abstract class facilitating the creation of type-specific bidirectional iterators.
|
| AbstractShortBigList
An abstract class providing basic methods for big lists implementing a type-specific big list interface.
|
| AbstractShortBigListIterator
An abstract class facilitating the creation of type-specific big-list iterators.
|
| AbstractShortCollection
An abstract class providing basic methods for collections implementing a type-specific interface.
|
| AbstractShortComparator
An abstract class facilitating the creation of type-specific comparators.
|
| AbstractShortIterator
An abstract class facilitating the creation of type-specific iterators.
|
| AbstractShortList
An abstract class providing basic methods for lists implementing a type-specific list interface.
|
| AbstractShortListIterator
An abstract class facilitating the creation of type-specific list iterators.
|
| AbstractShortPriorityQueue
An abstract class providing basic methods for priority queues implementing a type-specific interface.
|
| AbstractShortSet
An abstract class providing basic methods for sets implementing a type-specific interface.
|
| AbstractShortSortedSet
An abstract class providing basic methods for sorted sets implementing a type-specific interface.
|
| Short2BooleanArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2BooleanAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2BooleanFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2BooleanFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2BooleanFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2BooleanFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2BooleanFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2BooleanLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2BooleanMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2BooleanMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2BooleanMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2BooleanMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2BooleanMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2BooleanMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2BooleanMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2BooleanOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2BooleanOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2BooleanRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2BooleanSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2BooleanSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2BooleanSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2ByteArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ByteAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ByteFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ByteFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2ByteFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2ByteFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2ByteFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2ByteLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ByteMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ByteMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ByteMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2ByteMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2ByteMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2ByteMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2ByteMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2ByteOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ByteOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ByteRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ByteSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ByteSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2ByteSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2CharArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2CharAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2CharFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2CharFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2CharFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2CharFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2CharFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2CharLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2CharMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2CharMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2CharMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2CharMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2CharMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2CharMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2CharMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2CharOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2CharOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2CharRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2CharSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2CharSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2CharSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2DoubleArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2DoubleAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2DoubleFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2DoubleFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2DoubleFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2DoubleFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2DoubleFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2DoubleLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2DoubleMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2DoubleMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2DoubleMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2DoubleMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2DoubleMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2DoubleMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2DoubleMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2DoubleOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2DoubleOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2DoubleRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2DoubleSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2DoubleSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2DoubleSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2FloatArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2FloatAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2FloatFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2FloatFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2FloatFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2FloatFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2FloatFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2FloatLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2FloatMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2FloatMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2FloatMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2FloatMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2FloatMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2FloatMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2FloatMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2FloatOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2FloatOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2FloatRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2FloatSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2FloatSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2FloatSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2IntArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2IntAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2IntFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2IntFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2IntFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2IntFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2IntFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2IntLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2IntMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2IntMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2IntMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2IntMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2IntMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2IntMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2IntMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2IntOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2IntOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2IntRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2IntSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2IntSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2IntSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2LongArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2LongAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2LongFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2LongFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2LongFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2LongFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2LongFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2LongLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2LongMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2LongMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2LongMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2LongMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2LongMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2LongMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2LongMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2LongOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2LongOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2LongRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2LongSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2LongSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2LongSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2ObjectArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ObjectAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ObjectFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ObjectFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2ObjectFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2ObjectFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2ObjectFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2ObjectLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ObjectMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ObjectMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ObjectMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2ObjectMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2ObjectMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2ObjectMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2ObjectMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2ObjectOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ObjectOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ObjectRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ObjectSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ObjectSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2ObjectSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2ReferenceArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ReferenceAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ReferenceFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ReferenceFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2ReferenceFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2ReferenceFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2ReferenceFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2ReferenceLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ReferenceMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ReferenceMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ReferenceMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2ReferenceMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2ReferenceMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2ReferenceMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2ReferenceMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2ReferenceOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ReferenceOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ReferenceRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ReferenceSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ReferenceSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2ReferenceSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| Short2ShortArrayMap
A simple, brute-force implementation of a map based on two parallel backing arrays.
|
| Short2ShortAVLTreeMap
A type-specific AVL tree map with a fast, small-footprint implementation.
|
| Short2ShortFunction
A type-specific
Function ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ShortFunctions.EmptyFunction
An immutable class representing an empty type-specific function.
|
| Short2ShortFunctions.Singleton
An immutable class representing a type-specific singleton function.
|
| Short2ShortFunctions.SynchronizedFunction
A synchronized wrapper class for functions.
|
| Short2ShortFunctions.UnmodifiableFunction
An unmodifiable wrapper class for functions.
|
| Short2ShortLinkedOpenHashMap
A type-specific linked hash map with with a fast, small-footprint implementation.
|
| Short2ShortMap
A type-specific
Map ; provides some additional methods that use polymorphism to avoid (un)boxing, and handling of a default return value. |
| Short2ShortMap.Entry
A type-specific
Map.Entry ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| Short2ShortMap.FastEntrySet
An entry set providing fast iteration.
|
| Short2ShortMaps.EmptyMap
An immutable class representing an empty type-specific map.
|
| Short2ShortMaps.Singleton
An immutable class representing a type-specific singleton map.
|
| Short2ShortMaps.SynchronizedMap
A synchronized wrapper class for maps.
|
| Short2ShortMaps.UnmodifiableMap
An unmodifiable wrapper class for maps.
|
| Short2ShortOpenCustomHashMap
A type-specific hash map with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| Short2ShortOpenHashMap
A type-specific hash map with a fast, small-footprint implementation.
|
| Short2ShortRBTreeMap
A type-specific red-black tree map with a fast, small-footprint implementation.
|
| Short2ShortSortedMap
A type-specific
SortedMap ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| Short2ShortSortedMap.FastSortedEntrySet
A sorted entry set providing fast iteration.
|
| Short2ShortSortedMaps.EmptySortedMap
An immutable class representing an empty type-specific sorted map.
|
| ShortArrayFrontCodedList
Compact storage of lists of arrays using front coding.
|
| ShortArrayList
A type-specific array-based list; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ShortArrays.Segment |
| ShortArraySet
A simple, brute-force implementation of a set based on a backing array.
|
| ShortBidirectionalIterator
A type-specific bidirectional iterator; provides an additional method to avoid (un)boxing,
and the possibility to skip elements backwards.
|
| ShortBigArrayBigList
A type-specific big list based on a big array; provides some additional methods that use polymorphism to avoid (un)boxing.
|
| ShortBigList
A type-specific
BigList ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortBigListIterator
A type-specific
BigListIterator . |
| ShortBigListIterators.EmptyBigListIterator
A class returning no elements and a type-specific big list iterator interface.
|
| ShortBigLists.EmptyBigList
An immutable class representing an empty type-specific big list.
|
| ShortCollection
A type-specific
Collection ; provides some additional methods
that use polymorphism to avoid (un)boxing. |
| ShortCollections.EmptyCollection
An immutable class representing an empty type-specific collection.
|
| ShortCollections.SynchronizedCollection
A synchronized wrapper class for collections.
|
| ShortCollections.UnmodifiableCollection
An unmodifiable wrapper class for collections.
|
| ShortComparator
A type-specific
Comparator ; provides methods to compare two primitive types both as objects
and as primitive types. |
| ShortHash.Strategy
A type-specific hash strategy.
|
| ShortHeapSemiIndirectPriorityQueue
A type-specific heap-based semi-indirect priority queue.
|
| ShortIndirectPriorityQueue
A type-specific
IndirectPriorityQueue . |
| ShortIterable
A type-specific
Iterable that strengthens that specification of Iterable.iterator() . |
| ShortIterator
A type-specific
Iterator ; provides an additional method to avoid (un)boxing, and
the possibility to skip elements. |
| ShortIterators.EmptyIterator
A class returning no elements and a type-specific iterator interface.
|
| ShortLinkedOpenCustomHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ShortLinkedOpenHashSet
A type-specific linked hash set with with a fast, small-footprint implementation.
|
| ShortList
A type-specific
List ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortListIterator
A type-specific bidirectional iterator that is also a
ListIterator . |
| ShortLists.EmptyList
An immutable class representing an empty type-specific list.
|
| ShortLists.SynchronizedList
A synchronized wrapper class for lists.
|
| ShortLists.UnmodifiableList
An unmodifiable wrapper class for lists.
|
| ShortOpenCustomHashSet
A type-specific hash set with a fast, small-footprint implementation whose hashing strategy
is specified at creation time.
|
| ShortOpenHashSet
A type-specific hash set with with a fast, small-footprint implementation.
|
| ShortPriorityQueue
A type-specific
PriorityQueue ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSet
A type-specific
Set ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSets.EmptySet
An immutable class representing the empty set and implementing a type-specific set interface.
|
| ShortSets.Singleton
An immutable class representing a type-specific singleton set.
|
| ShortSets.SynchronizedSet
A synchronized wrapper class for sets.
|
| ShortSets.UnmodifiableSet
An unmodifiable wrapper class for sets.
|
| ShortSortedSet
A type-specific
SortedSet ; provides some additional methods that use polymorphism to avoid (un)boxing. |
| ShortSortedSets.EmptySet
An immutable class representing the empty sorted set and implementing a type-specific set interface.
|
| ShortStack
A type-specific
Stack ; provides some additional methods that use polymorphism to avoid (un)boxing. |
Copyright © 2019. All rights reserved.


THE MADNESS OF KING GEORGE A film review by Steve Rhodes Copyright 1995 Steve Rhodes
RATING (0 TO ****): * 1/2
THE MADNESS OF KING GEORGE is a movie based on the play titled THE MADNESS OF GEORGE III. It tells a little known story of King George III of England during the time (1789) right after he had "lost the Colonies." (I have been told it was retitled for the US because American audiences during the test marketing thought it was a sequel and wondered what happened in parts I and II, but I think that is just probably just another urban legend.)
The king (Nigel Hawthorne) is a strong-headed man who seems to those around him to be acting stranger and stranger. His estranged first son (Rupert Everett) seizes upon this and decides to try to get his old man declared insane in which case he would get to be Prince Regent. This would effectively make him king, and, most important of all, he would then get all of the king's vast income and wealth.
The loyal queen (Helen Mirren) stands by her man. Meanwhile Parliament splits on who to back with both sides caring only about politics and not a wit about the king or the prince. The king's side turns to a doctor played by Ian Holm. Finally, Amanda Plummer plays a loyal lady-in-waiting to the Queen who is willing to do absolutely anything to help her queen. Many twists and turns from there with an ending you may have some trouble predicting if you are not up on your British history of that era.
The historical story is fascinating and is the only reason to see the movie. The period costumes are well done, and the sets are carefully chosen. The acting is earnest, and Hawthorne does try awfully hard to present a believable madman.
On the bad side, the movie is extremely tedious and pedantic. For example, I lost count of how many times the scriptwriter had us hear about the color of the king's "water" and "stool." Moreover, we had to have numerous didactic lectures from doctors about the exact color of the king's "water" and much speculation on what the color meant. The best doctors in the land were also treated as nothing but quacks. Perhaps they were, but I wonder about the historical accuracy of this caricature. Finally, although the actors tried to give their best performances, I found that I did not care about any of the characters as written, and this comes from a guy who has taken seven vacations to Britain and who knows a lot of English history.
THE MADNESS OF KING GEORGE runs an overly long 1:50. It has no MPAA rating, but it is clearly a PG-13 show for a little profanity and for adult themes. This movie would be fine for any teenager. Other than British historians, I do not recommend this movie to anyone, and I award it * 1/2 solely for the history I learned by watching it.
**** = One of the top few films of this or any year. A must see film. *** = Excellent show. Look for it. ** = Average movie. Kind of enjoyable. * = Poor show.  Totally unbearable.
REVIEWED WRITTEN ON: January 27, 1995
Opinions expressed are mine and not meant to reflect my employer's.
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


|
Amplificador de Biopotenciales-BioAmp
v1.0.0
Amplificador de biopotenciales desarrollado en el Laboratorio de Prototipado Electrónico y 3D de la FIUNER en conjunto con el Laboratorio de Ingeniería en Rehabilitación e Investigaciones Neuromusculares y Sensoriales (LIRINS)
|
Macros | |
| #define | _RDATA 0x12 |
| #define | _RDATAC 0x10 |
| #define | _RESET 0x06 |
| #define | _SDATAC 0x11 |
| #define | _STANDBY 0x04 |
| #define | _START 0x08 |
| #define | _STOP 0x0A |
| #define | _WAKEUP 0x02 |
| #define | ACTIVATE (1) |
| #define | ACTIVATE_SHORTED (2) |
| #define | ADS_DRDY_PIN 12 |
| #define | ADS_DRDY_PORT 2 |
| #define | ADS_GAIN01 (0b00000000) |
| #define | ADS_GAIN02 (0b00010000) |
| #define | ADS_GAIN04 (0b00100000) |
| #define | ADS_GAIN06 (0b00110000) |
| #define | ADS_GAIN08 (0b01000000) |
| #define | ADS_GAIN12 (0b01010000) |
| #define | ADS_GAIN24 (0b01100000) |
| #define | ADS_ID 0x3E |
| #define | ADS_RST_PIN 8 |
| #define | ADS_RST_PORT 2 |
| #define | ADS_START_PIN 9 |
| #define | ADS_START_PORT 2 |
| #define | ADSINPUT_BIAL_DRN (0b00000111) |
| #define | ADSINPUT_BIAS_DRP (0b00000110) |
| #define | ADSINPUT_BIAS_MEAS (0b00000010) |
| #define | ADSINPUT_MVDD (0b00000011) |
| #define | ADSINPUT_NORMAL (0b00000000) |
| #define | ADSINPUT_SHORTED (0b00000001) |
| #define | ADSINPUT_TEMP (0b00000100) |
| #define | ADSINPUT_TESTSIG (0b00000101) |
| #define | ADSTESTSIG_AMP_1X (0b00000000) |
| #define | ADSTESTSIG_AMP_2X (0b00000100) |
| #define | ADSTESTSIG_DCSIG (0b00000011) |
| #define | ADSTESTSIG_NOCHANGE (0b11111111) |
| #define | ADSTESTSIG_PULSE_FAST (0b00000001) |
| #define | ADSTESTSIG_PULSE_SLOW (0b00000000) |
| #define | BIAS_SENSN 0x0E |
| #define | BIAS_SENSP 0x0D |
| #define | BIAS_SET (3) |
| #define | bitClear(value, bit) ((value) &= ~(1UL << (bit))) |
| #define | bitRead(value, bit) (((value) >> (bit)) & 0x01) |
| #define | bitSet(value, bit) ((value) |= (1UL << (bit))) |
| #define | BOARD_ADS 1 |
| #define | BOARD_ADS_PIN 16 |
| #define | BOARD_ADS_PORT 0 |
| #define | BOTH_ADS 3 |
| #define | CH1SET 0x05 |
| #define | CH2SET 0x06 |
| #define | CH3SET 0x07 |
| #define | CH4SET 0x08 |
| #define | CH5SET 0x09 |
| #define | CH6SET 0x0A |
| #define | CH7SET 0x0B |
| #define | CH8SET 0x0C |
| #define | CLICK_CFG 0x38 |
| #define | CLICK_SRC 0x39 |
| #define | CLICK_THS 0x3A |
| #define | CLK_EN 5 |
| #define | CONFIG1 0x01 |
| #define | CONFIG2 0x02 |
| #define | CONFIG3 0x03 |
| #define | CONFIG4 0x17 |
| #define | CTRL_REG1 0x20 |
| #define | CTRL_REG2 0x21 |
| #define | CTRL_REG3 0x22 |
| #define | CTRL_REG4 0x23 |
| #define | CTRL_REG5 0x24 |
| #define | CTRL_REG6 0x25 |
| #define | DEACTIVATE (0) |
| #define | FIFO_CTRL_REG 0x2E |
| #define | FIFO_SRC_REG 0x2F |
| #define | GAIN_SET (1) |
| #define | GPIO 0x14 |
| #define | ID_REG 0x00 |
| #define | INPUT_TYPE_SET (2) |
| #define | INT1_CFG 0x30 |
| #define | INT1_DURATION 0x33 |
| #define | INT1_SOURCE 0x31 |
| #define | INT1_THS 0x32 |
| #define | INT_COUNTER_REG 0x0E |
| #define | LOFF 0x04 |
| #define | LOFF_FLIP 0x11 |
| #define | LOFF_FREQ_31p2HZ (0b00000010) |
| #define | LOFF_FREQ_7p8HZ (0b00000001) |
| #define | LOFF_FREQ_DC (0b00000000) |
| #define | LOFF_FREQ_FS_4 (0b00000011) |
| #define | LOFF_MAG_24NA (0b00000100) |
| #define | LOFF_MAG_24UA (0b00001100) |
| #define | LOFF_MAG_6NA (0b00000000) |
| #define | LOFF_MAG_6UA (0b00001000) |
| #define | LOFF_SENSN 0x10 |
| #define | LOFF_SENSP 0x0F |
| #define | LOFF_STATN 0x13 |
| #define | LOFF_STATP 0x12 |
| #define | MISC1 0x15 |
| #define | MISC2 0x16 |
| #define | NCHAN (1) |
| #define | NO (0x00) |
| #define | OFF (0) |
| #define | ON (1) |
| #define | ON_BOARD (8) |
| #define | ON_DAISY (3) |
| #define | OUT_ADC1_H 0x09 |
| #define | OUT_ADC1_L 0x08 |
| #define | OUT_ADC2_H 0x0B |
| #define | OUT_ADC2_L 0x0A |
| #define | OUT_ADC3_H 0x0D |
| #define | OUT_ADC3_L 0x0C |
| #define | OUT_X_H 0x29 |
| #define | OUT_X_L 0x28 |
| #define | OUT_Y_H 0x2B |
| #define | OUT_Y_L 0x2A |
| #define | OUT_Z_H 0x2D |
| #define | OUT_Z_L 0x2C |
| #define | OUTPUT_16_CHAN (2) |
| #define | OUTPUT_8_CHAN (1) |
| #define | OUTPUT_NOTHING (0) |
| #define | PCHAN (0) |
| #define | PCKT_END 0xC0 |
| #define | PCKT_START 0xA0 |
| #define | POWER_DOWN (0) |
| #define | RATE_100HZ 0x50 |
| #define | RATE_10HZ 0x20 |
| #define | RATE_1250HZ_N 0x90 |
| #define | RATE_1600HZ_LP 0x80 |
| #define | RATE_1HZ 0x10 |
| #define | RATE_200HZ 0x60 |
| #define | RATE_25HZ 0x30 |
| #define | RATE_400HZ 0x70 |
| #define | RATE_5000HZ_LP 0x90 |
| #define | RATE_50HZ 0x40 |
| #define | READ_MULTI 0x40 |
| #define | READ_REG 0x80 |
| #define | REFERENCE 0x26 |
| #define | SAMPLE_RATE_16kHZ 0x00 |
| #define | SAMPLE_RATE_1kHZ 0x04 |
| #define | SAMPLE_RATE_250HZ 0x06 |
| #define | SAMPLE_RATE_2kHZ 0x03 |
| #define | SAMPLE_RATE_4kHZ 0x02 |
| #define | SAMPLE_RATE_500HZ 0x05 |
| #define | SAMPLE_RATE_8kHZ 0x01 |
| #define | SCALE_16G 0x30 |
| #define | SCALE_2G 0x00 |
| #define | SCALE_4G 0x10 |
| #define | SCALE_8G 0x20 |
| #define | SLAVE_ADS 2 |
| #define | SLAVE_ADS_PIN 28 |
| #define | SLAVE_ADS_PORT 1 |
| #define | SRB1_SET (5) |
| #define | SRB2_SET (4) |
| #define | STATUS_REG2 0x27 |
| #define | STATUS_REG_AUX 0x07 |
| #define | TIME_LATENCY 0x3C |
| #define | TIME_LIMIT 0x3B |
| #define | TIME_WINDOW 0x3D |
| #define | TMP_CFG_REG 0x1F |
| #define | WHO_AM_I 0x0F |
| #define | YES (0x01) |
"" Set of definitions used for controlling the ADS1299.
| #define _RDATA 0x12 |
Definition at line 46 of file Definitions_ADS1299.h.
| #define _RDATAC 0x10 |
Definition at line 44 of file Definitions_ADS1299.h.
| #define _RESET 0x06 |
Definition at line 41 of file Definitions_ADS1299.h.
| #define _SDATAC 0x11 |
Definition at line 45 of file Definitions_ADS1299.h.
| #define _STANDBY 0x04 |
Definition at line 40 of file Definitions_ADS1299.h.
| #define _START 0x08 |
Definition at line 42 of file Definitions_ADS1299.h.
| #define _STOP 0x0A |
Definition at line 43 of file Definitions_ADS1299.h.
| #define _WAKEUP 0x02 |
Definition at line 39 of file Definitions_ADS1299.h.
| #define ACTIVATE (1) |
Definition at line 133 of file Definitions_ADS1299.h.
| #define ACTIVATE_SHORTED (2) |
Definition at line 132 of file Definitions_ADS1299.h.
| #define ADS_DRDY_PIN 12 |
Definition at line 18 of file Definitions_ADS1299.h.
| #define ADS_DRDY_PORT 2 |
Definition at line 19 of file Definitions_ADS1299.h.
| #define ADS_GAIN01 (0b00000000) |
Definition at line 91 of file Definitions_ADS1299.h.
| #define ADS_GAIN02 (0b00010000) |
Definition at line 92 of file Definitions_ADS1299.h.
| #define ADS_GAIN04 (0b00100000) |
Definition at line 93 of file Definitions_ADS1299.h.
| #define ADS_GAIN06 (0b00110000) |
Definition at line 94 of file Definitions_ADS1299.h.
| #define ADS_GAIN08 (0b01000000) |
Definition at line 95 of file Definitions_ADS1299.h.
| #define ADS_GAIN12 (0b01010000) |
Definition at line 96 of file Definitions_ADS1299.h.
| #define ADS_GAIN24 (0b01100000) |
Definition at line 97 of file Definitions_ADS1299.h.
| #define ADS_ID 0x3E |
Definition at line 49 of file Definitions_ADS1299.h.
| #define ADS_RST_PIN 8 |
Definition at line 21 of file Definitions_ADS1299.h.
| #define ADS_RST_PORT 2 |
Definition at line 22 of file Definitions_ADS1299.h.
| #define ADS_START_PIN 9 |
Definition at line 24 of file Definitions_ADS1299.h.
| #define ADS_START_PORT 2 |
Definition at line 25 of file Definitions_ADS1299.h.
| #define ADSINPUT_BIAL_DRN (0b00000111) |
Definition at line 107 of file Definitions_ADS1299.h.
| #define ADSINPUT_BIAS_DRP (0b00000110) |
Definition at line 106 of file Definitions_ADS1299.h.
| #define ADSINPUT_BIAS_MEAS (0b00000010) |
Definition at line 102 of file Definitions_ADS1299.h.
| #define ADSINPUT_MVDD (0b00000011) |
Definition at line 103 of file Definitions_ADS1299.h.
| #define ADSINPUT_NORMAL (0b00000000) |
Definition at line 100 of file Definitions_ADS1299.h.
| #define ADSINPUT_SHORTED (0b00000001) |
Definition at line 101 of file Definitions_ADS1299.h.
| #define ADSINPUT_TEMP (0b00000100) |
Definition at line 104 of file Definitions_ADS1299.h.
| #define ADSINPUT_TESTSIG (0b00000101) |
Definition at line 105 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_AMP_1X (0b00000000) |
Definition at line 110 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_AMP_2X (0b00000100) |
Definition at line 111 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_DCSIG (0b00000011) |
Definition at line 114 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_NOCHANGE (0b11111111) |
Definition at line 115 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_PULSE_FAST (0b00000001) |
Definition at line 113 of file Definitions_ADS1299.h.
| #define ADSTESTSIG_PULSE_SLOW (0b00000000) |
Definition at line 112 of file Definitions_ADS1299.h.
| #define BIAS_SENSN 0x0E |
Definition at line 64 of file Definitions_ADS1299.h.
| #define BIAS_SENSP 0x0D |
Definition at line 63 of file Definitions_ADS1299.h.
| #define BIAS_SET (3) |
Definition at line 84 of file Definitions_ADS1299.h.
| #define bitClear | ( | value, | |
| bit | |||
| ) | ((value) &= ~(1UL << (bit))) |
Definition at line 208 of file Definitions_ADS1299.h.
| #define bitRead | ( | value, | |
| bit | |||
| ) | (((value) >> (bit)) & 0x01) |
Definition at line 209 of file Definitions_ADS1299.h.
| #define bitSet | ( | value, | |
| bit | |||
| ) | ((value) |= (1UL << (bit))) |
Definition at line 207 of file Definitions_ADS1299.h.
| #define BOARD_ADS 1 |
Definition at line 33 of file Definitions_ADS1299.h.
| #define BOARD_ADS_PIN 16 |
Definition at line 27 of file Definitions_ADS1299.h.
| #define BOARD_ADS_PORT 0 |
Definition at line 28 of file Definitions_ADS1299.h.
| #define BOTH_ADS 3 |
Definition at line 35 of file Definitions_ADS1299.h.
| #define CH1SET 0x05 |
Definition at line 55 of file Definitions_ADS1299.h.
| #define CH2SET 0x06 |
Definition at line 56 of file Definitions_ADS1299.h.
| #define CH3SET 0x07 |
Definition at line 57 of file Definitions_ADS1299.h.
| #define CH4SET 0x08 |
Definition at line 58 of file Definitions_ADS1299.h.
| #define CH5SET 0x09 |
Definition at line 59 of file Definitions_ADS1299.h.
| #define CH6SET 0x0A |
Definition at line 60 of file Definitions_ADS1299.h.
| #define CH7SET 0x0B |
Definition at line 61 of file Definitions_ADS1299.h.
| #define CH8SET 0x0C |
Definition at line 62 of file Definitions_ADS1299.h.
| #define CLICK_CFG 0x38 |
Definition at line 185 of file Definitions_ADS1299.h.
| #define CLICK_SRC 0x39 |
Definition at line 186 of file Definitions_ADS1299.h.
| #define CLICK_THS 0x3A |
Definition at line 187 of file Definitions_ADS1299.h.
| #define CLK_EN 5 |
Definition at line 140 of file Definitions_ADS1299.h.
| #define CONFIG1 0x01 |
Definition at line 51 of file Definitions_ADS1299.h.
| #define CONFIG2 0x02 |
Definition at line 52 of file Definitions_ADS1299.h.
| #define CONFIG3 0x03 |
Definition at line 53 of file Definitions_ADS1299.h.
| #define CONFIG4 0x17 |
Definition at line 73 of file Definitions_ADS1299.h.
| #define CTRL_REG1 0x20 |
Definition at line 165 of file Definitions_ADS1299.h.
| #define CTRL_REG2 0x21 |
Definition at line 166 of file Definitions_ADS1299.h.
| #define CTRL_REG3 0x22 |
Definition at line 167 of file Definitions_ADS1299.h.
| #define CTRL_REG4 0x23 |
Definition at line 168 of file Definitions_ADS1299.h.
| #define CTRL_REG5 0x24 |
Definition at line 169 of file Definitions_ADS1299.h.
| #define CTRL_REG6 0x25 |
Definition at line 170 of file Definitions_ADS1299.h.
| #define DEACTIVATE (0) |
Definition at line 134 of file Definitions_ADS1299.h.
| #define FIFO_CTRL_REG 0x2E |
Definition at line 179 of file Definitions_ADS1299.h.
| #define FIFO_SRC_REG 0x2F |
Definition at line 180 of file Definitions_ADS1299.h.
| #define GAIN_SET (1) |
Definition at line 82 of file Definitions_ADS1299.h.
| #define GPIO 0x14 |
Definition at line 70 of file Definitions_ADS1299.h.
| #define ID_REG 0x00 |
Definition at line 50 of file Definitions_ADS1299.h.
| #define INPUT_TYPE_SET (2) |
Definition at line 83 of file Definitions_ADS1299.h.
| #define INT1_CFG 0x30 |
Definition at line 181 of file Definitions_ADS1299.h.
| #define INT1_DURATION 0x33 |
Definition at line 184 of file Definitions_ADS1299.h.
| #define INT1_SOURCE 0x31 |
Definition at line 182 of file Definitions_ADS1299.h.
| #define INT1_THS 0x32 |
Definition at line 183 of file Definitions_ADS1299.h.
| #define INT_COUNTER_REG 0x0E |
Definition at line 162 of file Definitions_ADS1299.h.
| #define LOFF 0x04 |
Definition at line 54 of file Definitions_ADS1299.h.
| #define LOFF_FLIP 0x11 |
Definition at line 67 of file Definitions_ADS1299.h.
| #define LOFF_FREQ_31p2HZ (0b00000010) |
Definition at line 124 of file Definitions_ADS1299.h.
| #define LOFF_FREQ_7p8HZ (0b00000001) |
Definition at line 123 of file Definitions_ADS1299.h.
| #define LOFF_FREQ_DC (0b00000000) |
Definition at line 122 of file Definitions_ADS1299.h.
| #define LOFF_FREQ_FS_4 (0b00000011) |
Definition at line 125 of file Definitions_ADS1299.h.
| #define LOFF_MAG_24NA (0b00000100) |
Definition at line 119 of file Definitions_ADS1299.h.
| #define LOFF_MAG_24UA (0b00001100) |
Definition at line 121 of file Definitions_ADS1299.h.
| #define LOFF_MAG_6NA (0b00000000) |
Definition at line 118 of file Definitions_ADS1299.h.
| #define LOFF_MAG_6UA (0b00001000) |
Definition at line 120 of file Definitions_ADS1299.h.
| #define LOFF_SENSN 0x10 |
Definition at line 66 of file Definitions_ADS1299.h.
| #define LOFF_SENSP 0x0F |
Definition at line 65 of file Definitions_ADS1299.h.
| #define LOFF_STATN 0x13 |
Definition at line 69 of file Definitions_ADS1299.h.
| #define LOFF_STATP 0x12 |
Definition at line 68 of file Definitions_ADS1299.h.
| #define MISC1 0x15 |
Definition at line 71 of file Definitions_ADS1299.h.
| #define MISC2 0x16 |
Definition at line 72 of file Definitions_ADS1299.h.
| #define NCHAN (1) |
Definition at line 127 of file Definitions_ADS1299.h.
| #define NO (0x00) |
Definition at line 88 of file Definitions_ADS1299.h.
| #define OFF (0) |
Definition at line 128 of file Definitions_ADS1299.h.
| #define ON (1) |
Definition at line 129 of file Definitions_ADS1299.h.
| #define ON_BOARD (8) |
Definition at line 78 of file Definitions_ADS1299.h.
| #define ON_DAISY (3) |
Definition at line 79 of file Definitions_ADS1299.h.
| #define OUT_ADC1_H 0x09 |
Definition at line 157 of file Definitions_ADS1299.h.
| #define OUT_ADC1_L 0x08 |
Definition at line 156 of file Definitions_ADS1299.h.
| #define OUT_ADC2_H 0x0B |
Definition at line 159 of file Definitions_ADS1299.h.
| #define OUT_ADC2_L 0x0A |
Definition at line 158 of file Definitions_ADS1299.h.
| #define OUT_ADC3_H 0x0D |
Definition at line 161 of file Definitions_ADS1299.h.
| #define OUT_ADC3_L 0x0C |
Definition at line 160 of file Definitions_ADS1299.h.
| #define OUT_X_H 0x29 |
Definition at line 174 of file Definitions_ADS1299.h.
| #define OUT_X_L 0x28 |
Definition at line 173 of file Definitions_ADS1299.h.
| #define OUT_Y_H 0x2B |
Definition at line 176 of file Definitions_ADS1299.h.
| #define OUT_Y_L 0x2A |
Definition at line 175 of file Definitions_ADS1299.h.
| #define OUT_Z_H 0x2D |
Definition at line 178 of file Definitions_ADS1299.h.
| #define OUT_Z_L 0x2C |
Definition at line 177 of file Definitions_ADS1299.h.
| #define OUTPUT_16_CHAN (2) |
Definition at line 77 of file Definitions_ADS1299.h.
| #define OUTPUT_8_CHAN (1) |
Definition at line 76 of file Definitions_ADS1299.h.
| #define OUTPUT_NOTHING (0) |
Definition at line 75 of file Definitions_ADS1299.h.
| #define PCHAN (0) |
Definition at line 126 of file Definitions_ADS1299.h.
| #define PCKT_END 0xC0 |
Definition at line 137 of file Definitions_ADS1299.h.
| #define PCKT_START 0xA0 |
Definition at line 136 of file Definitions_ADS1299.h.
| #define POWER_DOWN (0) |
Definition at line 81 of file Definitions_ADS1299.h.
| #define RATE_100HZ 0x50 |
Definition at line 200 of file Definitions_ADS1299.h.
| #define RATE_10HZ 0x20 |
Definition at line 197 of file Definitions_ADS1299.h.
| #define RATE_1250HZ_N 0x90 |
Definition at line 204 of file Definitions_ADS1299.h.
| #define RATE_1600HZ_LP 0x80 |
Definition at line 203 of file Definitions_ADS1299.h.
| #define RATE_1HZ 0x10 |
Definition at line 196 of file Definitions_ADS1299.h.
| #define RATE_200HZ 0x60 |
Definition at line 201 of file Definitions_ADS1299.h.
| #define RATE_25HZ 0x30 |
Definition at line 198 of file Definitions_ADS1299.h.
| #define RATE_400HZ 0x70 |
Definition at line 202 of file Definitions_ADS1299.h.
| #define RATE_5000HZ_LP 0x90 |
Definition at line 205 of file Definitions_ADS1299.h.
| #define RATE_50HZ 0x40 |
Definition at line 199 of file Definitions_ADS1299.h.
| #define READ_MULTI 0x40 |
Definition at line 153 of file Definitions_ADS1299.h.
| #define READ_REG 0x80 |
Definition at line 152 of file Definitions_ADS1299.h.
| #define REFERENCE 0x26 |
Definition at line 171 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_16kHZ 0x00 |
Definition at line 143 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_1kHZ 0x04 |
Definition at line 147 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_250HZ 0x06 |
Definition at line 149 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_2kHZ 0x03 |
Definition at line 146 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_4kHZ 0x02 |
Definition at line 145 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_500HZ 0x05 |
Definition at line 148 of file Definitions_ADS1299.h.
| #define SAMPLE_RATE_8kHZ 0x01 |
Definition at line 144 of file Definitions_ADS1299.h.
| #define SCALE_16G 0x30 |
Definition at line 195 of file Definitions_ADS1299.h.
| #define SCALE_2G 0x00 |
Definition at line 192 of file Definitions_ADS1299.h.
| #define SCALE_4G 0x10 |
Definition at line 193 of file Definitions_ADS1299.h.
| #define SCALE_8G 0x20 |
Definition at line 194 of file Definitions_ADS1299.h.
| #define SLAVE_ADS 2 |
Definition at line 34 of file Definitions_ADS1299.h.
| #define SLAVE_ADS_PIN 28 |
Definition at line 30 of file Definitions_ADS1299.h.
| #define SLAVE_ADS_PORT 1 |
Definition at line 31 of file Definitions_ADS1299.h.
| #define SRB1_SET (5) |
Definition at line 86 of file Definitions_ADS1299.h.
| #define SRB2_SET (4) |
Definition at line 85 of file Definitions_ADS1299.h.
| #define STATUS_REG2 0x27 |
Definition at line 172 of file Definitions_ADS1299.h.
| #define STATUS_REG_AUX 0x07 |
Definition at line 155 of file Definitions_ADS1299.h.
| #define TIME_LATENCY 0x3C |
Definition at line 189 of file Definitions_ADS1299.h.
| #define TIME_LIMIT 0x3B |
Definition at line 188 of file Definitions_ADS1299.h.
| #define TIME_WINDOW 0x3D |
Definition at line 190 of file Definitions_ADS1299.h.
| #define TMP_CFG_REG 0x1F |
Definition at line 164 of file Definitions_ADS1299.h.
| #define WHO_AM_I 0x0F |
Definition at line 163 of file Definitions_ADS1299.h.
| #define YES (0x01) |
Definition at line 87 of file Definitions_ADS1299.h.


ABOUT
I am a junior web developer with past experience in business development and project management. I am particularly interested in building new technology, especially for entertainment, education, and space exploration. I am driven by the desire to use technology to redefine what is possible. I am seeking a junior web development at a leading technology company.
On this site you can take a look at my current and recent projects, check out my mostly technical blog, download my resume, and generally get to know me. Please feel free to contact me at<EMAIL_ADDRESS>-cgardens
On this site you can take a look at my current and recent projects, check out my mostly technical blog, download my resume, and generally get to know me. Please feel free to contact me at<EMAIL_ADDRESS>-cgardens


You have been given a tank, teleported to a sealed off island and face near destruction.
You have no hope of survival, all you can do is keep fighting and leave behind a legacy which the next participant will hear of..
There is no happy ending. Only try to survive as best you can, but be careful at night...
CONTROLS:
MOVEMENT: WASD (SHIFT to SPRINT!)
SHOOTING: ARROW KEYS
'M': Toggle Music || 'G': Toggle Sounds || 'ESC': Pause/Menu


Library: Foundation
Package: Streams
Header: Poco/BinaryWriter.h
Description
This class writes basic types (and std::vectors of these) in binary form into an output stream. It provides an inserter-based interface similar to ostream. The writer also supports automatic conversion from big-endian (network byte order) to little-endian and vice-versa. Use a BinaryReader to read from a stream created by a BinaryWriter. Be careful when exchanging data between systems with different data type sizes (e.g., 32-bit and 64-bit architectures), as the sizes of some of the basic types may be different. For example, writing a long integer on a 64-bit system and reading it on a 32-bit system may yield an incorrent result. Use fixed-size types (Int32, Int64, etc.) in such a case.
Inheritance
Known Derived Classes: BasicMemoryBinaryWriter
Member Summary
Member Functions: bad, byteOrder, fail, flush, good, operator <<, stream, write7BitEncoded, writeBOM, writeRaw
Enumerations
StreamByteOrder
the host's native byte-order
big-endian (network) byte-order
big-endian (network) byte-order
little-endian byte-order
Constructors
BinaryWriter
BinaryWriter(
std::ostream & ostr,
StreamByteOrder byteOrder = NATIVE_BYTE_ORDER
);
Creates the BinaryWriter.
BinaryWriter
BinaryWriter(
std::ostream & ostr,
TextEncoding & encoding,
StreamByteOrder byteOrder = NATIVE_BYTE_ORDER
);
Creates the BinaryWriter using the given TextEncoding.
Strings will be converted from the currently set global encoding (see Poco::TextEncoding::global()) to the specified encoding.
Destructor
~BinaryWriter
~BinaryWriter();
Destroys the BinaryWriter.
Member Functions
bad
bool bad();
Returns _ostr.bad();
byteOrder
StreamByteOrder byteOrder() const;
Returns the byte ordering used by the writer, which is either BIG_ENDIAN_BYTE_ORDER or LITTLE_ENDIAN_BYTE_ORDER.
fail
bool fail();
Returns _ostr.fail();
flush
void flush();
Flushes the underlying stream.
good
bool good();
Returns _ostr.good();
operator <<
BinaryWriter & operator << (
bool value
);
operator <<
BinaryWriter & operator << (
char value
);
operator <<
BinaryWriter & operator << (
unsigned char value
);
operator <<
BinaryWriter & operator << (
signed char value
);
operator <<
BinaryWriter & operator << (
short value
);
operator <<
BinaryWriter & operator << (
unsigned short value
);
operator <<
BinaryWriter & operator << (
int value
);
operator <<
BinaryWriter & operator << (
unsigned int value
);
operator <<
BinaryWriter & operator << (
long value
);
operator <<
BinaryWriter & operator << (
unsigned long value
);
operator <<
BinaryWriter & operator << (
float value
);
operator <<
BinaryWriter & operator << (
double value
);
operator <<
BinaryWriter & operator << (
const std::string & value
);
operator <<
BinaryWriter & operator << (
const char * value
);
operator <<
template < typename T > BinaryWriter & operator << (
const std::vector < T > & value
);
stream
std::ostream & stream() const;
Returns the underlying stream.
write7BitEncoded
void write7BitEncoded(
UInt32 value
);
Writes a 32-bit unsigned integer in a compressed format. The value is written out seven bits at a time, starting with the seven least-significant bits. The high bit of a byte indicates whether there are more bytes to be written after this one. If value will fit in seven bits, it takes only one byte of space. If value will not fit in seven bits, the high bit is set on the first byte and written out. value is then shifted by seven bits and the next byte is written. This process is repeated until the entire integer has been written.
write7BitEncoded
void write7BitEncoded(
UInt64 value
);
Writes a 64-bit unsigned integer in a compressed format. The value written out seven bits at a time, starting with the seven least-significant bits. The high bit of a byte indicates whether there are more bytes to be written after this one. If value will fit in seven bits, it takes only one byte of space. If value will not fit in seven bits, the high bit is set on the first byte and written out. value is then shifted by seven bits and the next byte is written. This process is repeated until the entire integer has been written.
writeBOM
void writeBOM();
Writes a byte-order mark to the stream. A byte order mark is a 16-bit integer with a value of 0xFEFF, written in host byte-order. A BinaryReader uses the byte-order mark to determine the byte-order of the stream.
writeRaw
void writeRaw(
const std::string & rawData
);
Writes the string as-is to the stream.
writeRaw
void writeRaw(
const char * buffer,
std::streamsize length
);
Writes length raw bytes from the given buffer to the stream.