- nearCells() - Method in class it.polimi.sw2019.model.Cell
-
- nearCellsTest() - Method in class it.polimi.sw2019.TestCell
-
verifies if the near cells match with the neighbors cells
- nonVisible(Player) - Method in class it.polimi.sw2019.model.Visibility
-
used to know targets for NONVISIBLE effects
- nonVisibleTest() - Method in class it.polimi.sw2019.TestVisibility
-
- notify(Message) - Method in interface it.polimi.sw2019.network.client.ClientInterface
-
notify a message to the client
- notify(Message) - Method in class it.polimi.sw2019.network.client.rmi.ClientImplementation
-
method to send the message to the client
- notify(Message) - Method in class it.polimi.sw2019.network.client.socket.SocketClientConnection
-
notify message to client
- notify(Message, Server, String) - Method in class it.polimi.sw2019.network.server.Client
-
method to send a message to the client
- notify(Message) - Method in class it.polimi.sw2019.network.server.socket.SocketServerClientHandler
-
this method is used to notify something to the client
- notify(Message) - Method in class it.polimi.sw2019.network.server.VirtualView
-
this method sends the message to the controller
- notify(Message) - Method in class it.polimi.sw2019.VirtualViewSimulator
-
- notifyMatchState() - Method in class it.polimi.sw2019.model.Match
-
method used to send infos about the match to the view
- notifyPrivateHand(Player) - Method in class it.polimi.sw2019.model.Match
-
method used to send info about the hand of a player to the view
- notifyPrivateHand() - Method in class it.polimi.sw2019.model.Player
-
create infos about the hadn of the player to send to its view
- notifyPrivateHandTest() - Method in class it.polimi.sw2019.TestPlayer
-


Owning Palette: Utility VIs
Requires: Logger
A prompt is displayed to a user based on the configured Verbosity and the selected Severity. There are four possible severities for an error: (1) FATAL, (2) RECOVERABLE, (3) WARNING, and (4) BENIGN. FATAL errors are logged at the FATAL level, RECOVERABLE errors are logged at the ERROR level, WARNING errors are logged at the INFO level, and BENIGN errors are logged at the DEBUG level. If the Verbosity is greater than or equal to the Severity of the error, a dialog is displayed.
This is essentially a wrapper for the General Error Handler VI but integrates its usage with the logger.
| Severity is used to determine if an error dialog, or prompt, should be displayed if an error occurs. | |
| Error In describes error conditions that occur before this node runs. This input contains status, code, and source, which provide standard error in cluster element functionality. |
|
| Source is an optional string to describe the source of the error. If empty, then the parent VI calling this VI is used as the source. | |
| Clear determines if the error should be cleared after possibly displaying a prompt and logging the error. If FALSE, then the error is propogated to Error Out. Regardless if TRUE or FALSE, errors are prompted based on Verbosity and Severity and converted to logging statements. By default, FATAL errors, where Severity is equal to FATAL, are not cleared, but all other severities are cleared. |
|
| Error Out contains error information. This output provides standard error out functionality. |


About
Hi, I’m Adarsh. Currently, I work as an Applied Scientist in the Alexa Search Team in Los Angeles, CA.
Previously, I obtained my Masters in Computer Sciences Department from University of Wisconsin-Madison, where I worked with Prof. Aditya Akella, Prof. Shivaram Venkataraman and Prof. Yingyu Liang. At UW-Madison, I worked on the problems related to Machine Learning and Systems.
Before joining UW-Madison, I worked as an Applied Scientist in the Bing, Microsoft. I completed my Bachelors in Mathematics & Computing from Indian Institute of Technology-Guwahati in 2016.


Our group at Indian Institute of Science Education and Research Bhopal works in the area of soft-condensed matter physics. Our specific interest lies in the soft and biological material that are driven out of equilibrium either by interactivity or by external field. Such active material exhibit very interesting emergent behavior. We employ theoretical and computational tools to investigate the rich dynamics exhibited by such systems.
Broad areas of interest in the group are biophysics and soft-condensed matter physics. In the theoretical studies to understand various physical and biological phenomena the group uses variety of tools from physics including equilibrium and non-equilibrium statistical mechanics, polymer physics and soft-matter theory. Specific areas of interest include


Thiruvananthapuram- Our Package
Napier Museum
Padmanabha Swamy Temple
Poovar Island
Varkala Cliff
Kovalam Beach
Contact Us at keralatourism@gmail.com


Site Registration Form Please complete the following form to register for our site First Name: (First Name) Last Name: (Last Name) Email<EMAIL_ADDRESS>Please fill out our optional survey Tell Us About You Professional Student IT Passionate Contact Web Administrator @ email@uta.edu


--- layout: post title: 'MoMo London: Matt Millar, Adobe' date: 2006-01-09 00:00:00 categories: digital-media interfaces-&-interaction mobile ---
Matt Millar, Adobe
Wants to talk about drivers for experience on mobile.
Mobile user experience is an undelivered promise. "The UE is your customers relationship with you". More enjoyable = more use = (for most folks) more revenue. As switching costs go down, experience matters more. We're all in the fashion business - it's good enough to be technically great, it needs personality.
Experience is *not* "making it pretty".
The WAP model isn't right. Chopping up the internet for a small screen doesn't work. We need (surprise surprise) a rich client model.
Cell phones operate more like game controllers - texting without looking. (Fair to note that predictive text makes this tricky/impossible).
Myth: chrome is cool. Surface content to the top. Feedback is more important than visual affordance. Use natural, visual metaphors.
Myth: animation is gratuitous. Actually, humans are good at motion tracking.
Myth: more visible features = more value. Every screen needs a clear call to action.
Myth: one size fits all.
Overall: he's very much trying to dampen down the worst excesses of Flash.
Canned demo of watching a film trailer, clicking to see more times, mapping, grabbing voucher, etc.. Looks either fantastic or a collection of mobile cliches. Memo to self: cut down on caffeine before next MoMo.


This is the core module in sheetsee and is included in all builds. It contains the functions for building your custom file as well as the basic data manipulation functions.
Tabletop.js will fetch the data from your spreadsheet and return it as an array of objects. Sheetsee.js has functions built in to help you filter or reorganize the data if you'd like.
This takes in your data, an array of objects, and searches for a string, groupTerm, in each piece of your data (formerly the cells of your spreadsheet). It returns the number of times it found the groupTerm.
getGroupCount(data, "cat")
// returns a number
Given your data, an array of objects, and a string column header, this functions sums each cell in that column(so this collumn you mention best have numbers).
getColumnTotal(data, "cuddlability")
// returns number
A really simple function that builds on getColumnTotal()
by returning the average number in a column of numbers.
getColumnAverage(data, "cuddlability")
// returns number
This will return an array of object or objects (if there is a tie) of the element with the lowest number value in the column you specify from your data.
getMin(data, "cuddlability")
// returns array
This will return an array of object or objects (if there is a tie) of the element with the highest number value in the column you specify from your data.
getMin(data, "cuddlability")
// returns array
Create variables that are the sums, differences, multiples and so forth of others. Lots of info on that here on MDN.
var profit09 = Sheetsee.getColumnTotal(data, "2009")
var profit10 = Sheetsee.getColumnTotal(data, "2010")
var difference = profit09 - profit10
You don't have to just create tables of your data. You can have other portions of your page that show things like, "The difference taco consumption between last week and this week is..." These are easy to create with JavaScript math functions and knowing a little bit more about icanhaz.js.
Takes data as an array of objects, a string you'd like to filter and a string of the category you want it to look in (a column header from your spreadsheet).
getMatches(data, "dog", "kind")
Returns an array of objects matching the category's filter.
[{"name": "coco", "kind": "dog"...}, {"name": "wolfgang", "kind": "dog"...},{"name": "cooc", "kind": "dog"...} ]
Takes data as an array of objects and a string for category (a column header from your spreadsheet) you want tally how often an element occured.
getOccurance(data, "kind")
Returns an object with keys and values for each variation of the category and its occurance.
{"dog": 3, "cat": 3}
If you use getOccurance()
and want to then chart that data with d3.js, you'll need to make it into an array (instead of an object) and add colors back in (since the hexcolor column applies to the datapoints in your original dataset and not this new dataset).
This function takes in your data, as an object, and an array of hexidecimal color strings which you define.
var kinds = getOccurance(data, "kind")
var kindColors = ["#ff00ff", "#DCF13C"]
var kindData = makeColorArrayOfObjects(mostPopBreeds, breedColors)
It will return an array of objects formatted to go directly into a d3 chart with the appropriate units and label keys, like so:
[{"label": "dog", "units": 2, "hexcolor": "#ff00ff"}, {"label": "cat", "units": 3, "hexcolor": "#DCF13C"}]
If you pass in an array of just one color it will repeat that color for all items. If you pass fewer colors than data elements it will repeat the sequences of colors for the remainder elements.
If you're using data, the data directly from Tabletop, you'll need to format it before you use the d3 charts. You'll need to determine what part of your data you want to chart - what will be your label, what your charting, and what will be your units, how many of them are there (this should be a number).
var data = [{"name": "coco", "kind": "dog", "cuddablity": 5}, {"name": "unagi", "kind": "cat", "cuddlability": 0}]
For istance, if from our original data above we want to chart the age of each cat, we'll use:
Sheetsee.addUnitsLabels(data, "name", "cuddlability")
Which will return an array, ready for the d3 charts:
[{"label": "coco", "kind": "dog", "units": 5}, {"label": "unagi", "kind": "cat", "units": 0}]


Sanchari Bhattacharya
Research Portfolio
Research Part A
Research Part B
Publications & Awards
Please contact me for more information. Thank you for reading.
Contact Information
505-795-8336
sancharidas22@gmail.com


Someone casts a doppelganger spell at Hogwarts ! On the map you need to find all the matches of the characters to break this spell.
Someone casts a doppelganger spell at Hogwarts ! On the map you need to find all the matches of the characters to break this spell.


This section contains release notes for all versions 471 and above. Version 470 was the first public release version. Version 471 was the first update after public release.
Release notes are integral to the Nyzo development process. Every commit to the Nyzo verifier repository is now uniquely numbered, and release notes are now published in tandem with every commit.
With rare exceptions that are explained, release notes now contain screenshots of every code change except for import statements, and a simple description of every logic change is included.
The release notes are intended to improve democratization through better community understanding of the code, improve security through more transparent detailing of logic modifications, and improve code quality by forcing the Nyzo team to review and explain every line of code before it is released publicly.


Hello, I am “Bikash Jaiswal”. I am working as Research Assistant at Department of Computer Science and Engineering, Tezpur University. Currently, My works are focused for Center of Excellence project entitled Machine Learing Research and Big Data Analytics underwritten by Ministry of Human, Resource and Development (MHRD), Government of India.
During my Undergraduate, I have worked on Bioinformatics, concentrating on Breast-cancer microarrays datasets. A parallel method for module extraction was proposed and implemented by harnessing the power of GPU on heyday of B-tech program. The method was able to predict 5 unprecedented genes as causal genes for Breast-cancer.
This blog is resemblance of some chuck of my research and peculiar stuff that entice as well as confound me on daily to daily basis.
You can contact me at


Creating a convertor means creating a new class which subclasses
the abstract Convertor
class.
read
and write
should contain
an converting algorithm.
Methods registerSaver
and unregisterSaver
allow
to define own logic to detect changes in a setting object and notify the framework
about these changes via Saver interface.
Notifications are interpreted as requests to store the object or to mark it as
changed (e.g the framework provides SaveCookie).
E.g. you can incorporate the property change support in your setting object as
the source of notifications. The Convertor.registerSaver
will register own listener and filter fired events you want the framework to be notified.
Each .settings
file containing values
in the format supported by your convertor has to be headed by DOCTYPE containing
a public identifier defining grammar used for entity registrations.
First you should register an entity beneath xml/entities
according to public identifier
in the module layer. That registration has to be in the shape recognizable by a
system entity resolver.
<folder name="xml"> <folder name="entities"> <!--Entity registration--> <folder name="Vendor_org_netbeans_modules_foo"> <file name="DTD_FooSetting_1_0" url="nbres:/org/netbeans/modules/foo/entity-1_0.dtd"> <attr name="hint.originalPublicID" stringvalue="-//Vendor org.netbeans.modules.foo//DTD FooSetting 1.0//EN"/> </file> </folder> </folder> </folder>
Next register the Environment Provider associated with the entity under xml/lookups
. The registration
has to contain following attributes
<folder name="xml"> <folder name="lookups"> <folder name="Vendor_org_netbeans_modules_foo"> <file name="DTD_FooSetting_1_0.instance"> <!--Environment Provider provided by the settings module--> <attr name="instanceCreate" methodvalue="org.netbeans.api.settings.Factory.create"/> <!--Custom convertor object--> <attr name="settings.convertor" methodvalue="org.netbeans.modules.foo.FooConvertor.create"/> <!--class name of the setting object--> <attr name="settings.instanceClass" stringvalue="org.netbeans.modules.foo.FooSetting"/> <!--the setting object; optional attribute; here you can specify a factory producing object into which stored data are read. The produced object should conform the settings.instanceClass attribute--> <attr name="settings.instanceCreate" methodvalue="org.netbeans.modules.foo.FooSetting.create"/> <!--class name and subclass names of the setting object separated by comma; used for performance reasons; be careful what you include or exclude here to ensure your setting is accessible via the Lookup API --> <attr name="settings.instanceOf" stringvalue="org.netbeans.modules.foo.FooSetting"/> <!--plus attributes specific to your convertor--> </file> </folder> </folder> </folder>
settings.providerPath
under
xml/memory
folder. The attribute has to contain path to the environment provider
associated with a proper entity registration.
<folder name="xml"> <folder name="memory"> <folder name="org"> <folder name="netbeans"> <folder name="modules"> <folder name="foo"> <!--allows to create .settings file from memory via InstanceDataObject.create--> <file name="FooSetting"> <attr name="settings.providerPath" stringvalue="xml/lookups/Vendor_org_netbeans_modules_foo/DTD_FooSetting_1_0.instance"/> </file> </folder> </folder> </folder> </folder> </folder> </folder>To create a persistent instance use method org.openide.loaders.InstanceDataObject.create. The framework will look up the provider registration for the exact class of the object passed into the method.
If you have a special setting convertor capable of converting of objects
of its class and of all of its superclasses you might want to specify also
attribute settings.subclasses
with boolean value set to true like this:
<folder name="xml"> <folder name="memory"> <folder name="org"> <folder name="netbeans"> <folder name="modules"> <folder name="foo"> <!--allows to create .settings file from memory via InstanceDataObject.create--> <file name="FooSetting"> <attr name="settings.providerPath" stringvalue="xml/lookups/Vendor_org_netbeans_modules_foo/DTD_FooSetting_1_0.instance"/> <attr name="settings.subclasses" boolvalue="true"/> </file> </folder> </folder> </folder> </folder> </folder> </folder>
Please use the attribute settings.subclasses
only in case
you are sure your convertor can handle all subclasses!
DOMConvertor
allowing to delegate reading and writing of setting object's properties (e.g. complex objects)
to already existing convertors.
The delegating is handled by methods DOMConvertor.delegateRead/delegateWrite
which
are able to look up a proper registered
Convertor
according to a class of a setting object (see registration for
runtime instances) and according to a public ID (see registration for
entities) specified as an attribute (dtd_public_id
) of a xml element.
There are two ways in which is the delegation handled:
DOMConvertor
is available read/write operation is delegated to
DOMConvertor.readElement
or DOMConvertor.writeElement
which are
supposed to be rewritten by subclasses.
DOMConvertor
is not available a plain Convertor
is used and its output
is encapsulated in a CDATA block inside the domconvertor
element.
complex_property
which was written via SubclassedDOMConvertor.writeElement and plugged by DOMConvertor.delegateWrite into document:
... <complex_property dtd_public_id="-//Vendor ...//EN"> <foo /> </complex_property> ...Other XML fragment shows a complex property written via a SubclassedConvertor.write and plugged by DOMConvertor.delegateWrite into document:
... <domconvertor dtd_public_id="-//Vendor ...//EN"><[!CDATA[...]]></domconvertor> ...
The DOMConvertor.delegateRead/delegateWrite
also solve multiple references of an object
that can appear in scope of a XML document. Attributes ID
and IDREF
are used in accordance with the XML specification .
... <foosetting dtd_public_id="-//Vendor ...//EN" id="1"> </foosetting ... <domconvertor idref="1"/> ...
Utilizing of Document Object Model (DOM) Level 2 Core Specification facilitates code formatting of the output and also provides APIs describing the hierarchy of nested elements, arbitrary complex.
Services
folder. This is useful for settings shared among modules.
Otherwise you can place the file under own folder and use DataSystem API to get the object.
FileObject fo = FileUtil.getConfigFile("YourFolder/YourSetting.settings"); DataObject dobj = DataObject.find(fo); InstanceCookie ic = (InstanceCookie) dobj.getCookie(InstanceCookie.class); Object setting = ic.instanceCreate();
settings.instanceClass
and settings.instanceOf
. If an old class
is referenced inside the format use META-INF/netbeans/translate.names
file.
settings.providerPath
as was described in the section about creating settings in the runtime.
Do not remove the old registration! The framework will read the file via original
convertor but changes will be stored via new one.
<!ELEMENT properties (property*)> <!ELEMENT property EMPTY> <!ATTLIST property name CDATA #REQUIRED value CDATA #REQUIRED >
To create a setting object class compatible with the XMLProperties convertor
the class has to contain the property change support
(like java.beans.ProperyChangeSupport) to make possible to register java.beans.PropertyChangeListener
, implement public default constructor
(if the settings.instanceCreate
attribute is not used). To collect
data supposed to be persisted following methods have to be present:
<ANY-ACCESS-MODIFIER> void readProperties(java.util.Properties p)and
<ANY-ACCESS-MODIFIER> void writeProperties(java.util.Properties p)It is the setting object concern to collect all properties of its super classes. Since version 1.18, the
readProperties
can also return an Object.
In such case, the XMLPropertiesConvertor
replaces the current object
with the returned one.
The XMLProperties convertor also makes possible to prevent automatic storing
of the setting object by using file attribute xmlproperties.preventStoring
in the module layer.
The attribute can contain the value whether the setting object will be
stored automatically (xmlproperties.preventStoring==false
) or SaveCookie
will be provided. Default value is false
. Usage
<attr name="xmlproperties.preventStoring" boolvalue="[true|false]"/>The second additional attribute is
xmlproperties.ignoreChanges
specifying property change events by comma separated list
of property names which will be ignored. You can use special token all
to ignore all events. Usage
<attr name="xmlproperties.ignoreChanges" stringvalue="name[, ...]"/>
Here is an example of registrations in a module layer necessary to properly handle FooSetting object persisted in the properties format.
<folder name="xml"> <!--First you need to register own public identifier--> <folder name="entities"> <!--the public identifier registration--> <folder name="NetBeans_org_netbeans_modules_foo"> <file name="DTD_FooSetting_1_0" url="nbres:/org/netbeans/modules/settings/resources/properties-1_0.dtd"> <attr name="hint.originalPublicID" stringvalue="-//NetBeans org.netbeans.modules.foo//DTD FooSetting 1.0//EN"/> </file> </folder> </folder> <!--Follows XMLPropertiesConvertor registration with proper attributes--> <folder name="lookups"> <!--the environment provider registration--> <folder name="NetBeans_org_netbeans_modules_foo"> <file name="DTD_FooSetting_1_0.instance"> <!--env. provider--> <attr name="instanceCreate" methodvalue="org.netbeans.api.settings.Factory.create"/> <!--XMLProperties convertor provided by the settings module--> <attr name="settings.convertor" methodvalue="org.netbeans.api.settings.Factory.properties"/> <attr name="settings.instanceClass" stringvalue="org.netbeans.modules.foo.FooSetting"/> <attr name="settings.instanceOf" stringvalue="org.netbeans.modules.foo.FooSetting"/> <!--changes of propertyName1, propertyName2 will be ignored--> <attr name="xmlproperties.ignoreChanges" stringvalue="propertyName1, propertyName2"/> <!--the setting object will not be stored automatically--> <attr name="xmlproperties.preventStoring" boolvalue="true"/> </file> </folder> </folder> <!--FooSetting class to XMLPropertiesConvertor mapping (for persistent instances created in the runtime)--> <folder name="memory"> <folder name="org"> <folder name="netbeans"> <folder name="modules"> <folder name="foo"> <!--allows to create .settings file from memory via InstanceDataObject.create--> <file name="FooSetting"> <attr name="settings.providerPath" stringvalue="xml/lookups/NetBeans_org_netbeans_modules_foo/DTD_FooSetting_1_0.instance"/> </file> </folder> </folder> </folder> </folder> </folder> </folder> <!--And here is the FooSetting data registration containing default values--> <folder name="Services"> <!--the .settings data file registration--> <file name="org-netbeans-modules-foo-FooSetting.settings" url="FooSetting.xml"> <!-- SystemFileSystem.localizedName and SystemFileSystem.icon as usual --> </file> </folder>
FooSetting.xml
containing the persisted setting object:
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE properties PUBLIC "-//NetBeans org.netbeans.modules.foo//DTD FooSetting 1.0//EN" "http://www.netbeans.org/dtds/properties-1_0.dtd" <properties> <property name="property1Name" value="xxx"/> <property name="property2Name" value="xxx"/> </properties>
FooSetting
class would look like:
public final class FooSetting { private final static String PROP_PROPERTY1NAME = "property1Name"; //NOI18N ... public FooSetting() {...} // property change event support public void addPropertyChangeListener(java.beans.PropertyChangeListener l) {...} public void removePropertyChangeListener(java.beans.PropertyChangeListener l) {...} // getters/setters public String getPropery1() {...} public void setProperty1(Object property1) { ... // fire a property change event } // readProperties/writeProperties called by XMLPropertiesConvertor private void readProperties(java.util.Properties p) { property1 = p.getProperty(PROP_PROPERTY1NAME); ... } private void writeProperties(java.util.Properties p) { p.setProperty(PROP_PROPERTY1NAME, property1); ... } ... }


Look: Nationals troll Phillies by parading championship buses around Philadelphia
by TSD StaffThere’s some serious trolling going on in the City of Brotherly Love right now, and the motive for it can likely be traced back to Bryce Harper.
The Nationals attempted to re-sign Harper last winter, but he, instead, chose to sign with the team’s biggest division rival. It appeared that the Phillies were always Harper’s first choice, and the rest of the noise was just a bidding war, so that’s where he ended up landing.
But the Nationals have been paying him back with some good old-fashioned trolling, most of it on social media. And their fans have been doing it even more.
Not only that, someone elected to have one of the Nationals championship buses drive around Philly, which is a Defcon 5 level troll job.
It’s unclear who was behind this, but given that GEICO’s name is on the bus, that’s a good starting point.


HOW IT WORKS?
We have made laundry service easy and fast
Find the best laundry service near you and order
We will pickup it from your door and deliver it at your door
We will pickup it from your door and deliver it at your door
Find the best laundry service near you and order
We will pickup it from your door and deliver it at your door
We will pickup it from your door and deliver it at your door


1 View multiple floors
- View up to 4 floors simultaneously! The default is based on your screen size, but can be changed in the top right menu.
- Tip: Clicking/tapping will display a pink marker on all floors that can help you idenitfy what is directly above/below a location.
2 Room label styles
- Choose from light, dark, and large combos!
3 Camera line of sights
- Cameras now have line of sight markings indicating their coverage.
- Tip: Hovering over a camera highlights its line of sight. You can also adjust the starting opacity in the top right menu.
4 Select map grid
- Now shows when you first arrive at R6Maps.com. Toggle it by clicking/tapping the top left logo.
5 German translations
Plus more ...and what's next
- Menu Check out the top right menu for other new features. Options selected are saved per device).
- Issues? Feedback? If you notice any defects please contact me or log your issue here (for example: bad translations, device incompatibility, feature requests).
- What's next? In a few weeks, beta test a real-time team collaboration session feature in order to determine how useful it could be.
- If you want to help test new features like that, or just want to play some games and have fun, you can find me on Uplay! :)


Log Class
A lightweight component for gathering and emitting application logs
It's designed with low development and runtime cost in mind, encouraging usage with minimum concern for overhead. Runtime monitoring can be as chatty as desired, outputting every log statement of every type, or finely tuned with regular expressions to monitor specific log statements.
Log Collector
As a collector, it's a place to send application logs.
Example for outputting a log in your application:
var log = require('monitor-min').getLogger('myModule');
...
log.info('Credit limit accepted', limit, requestedAmount);
The above is a request to output an info
log for myModule
named
Credit limit accepted
. The log entry includes all additional parameters,
in this case the customer credit limit and the reqeusted amount.
The full name for this log entry is: "info.myModule.Credit limit accepted"
The name is important, as monitors can be configured to output logs based
on this name.
Best practices are to include dynamic parameters in extra arguments vs. concatenating strings. This reduces logging overhead, especially for log statements that aren't currently being watched.
Log Emitter
As an emitter, the Log module is a place to capture logging output.
When listening for log entries, wildcards can be used to register for particular log types and entries.
var Log = require('monitor-min').Log;
...
Log.on('info.myModule.*', myFunction);
Will call myFunction
when all info.myModule.*
logs are emitted.
Listeners are invoked with the following arguments:
- type - The log type (trace, debug, info, warn, error, or fatal)
- module - The logger module name
- name - The log entry name
- args... - Additional arguments passed into the log entry are passed on as additional args to the event listener.
Wildcards
A flexible and user-oriented wildcard pattern is used for monitoring logs. The pattern is described in the Wildcard secttion of the Stats class.
Choosing Good Names
It's a good idea to pick a good naming scheme with each dot-delimited segment having a consistent, well-defined purpose. Volatile segments should be as deep into the hierarchy (furthest right) as possible. Keeping the names less volatile makes it easier to turn statistics recording on for all logs.
Constructor
Methods
consoleLogger
-
type
-
module
-
name
-
args
Output log statements to the console
This method can be used as a listener to send logs to the console.
It uses console.error() for error and fatal log types, and console.log() for all other log types.
Example:
var Log = Monitor.Log;
Log.on('*.MyModule.*', Log.console);
debug
-
name
-
[...]
Output a debug
log entry
Parameters:
-
name
StringLog entry name
-
[...]
Any optionalSubsequent arguments to add to the log
error
-
name
-
[...]
Output a error
log entry
Parameters:
-
name
StringLog entry name
-
[...]
Any optionalSubsequent arguments to add to the log
fatal
-
name
-
[...]
Output a fatal
log entry
Parameters:
-
name
StringLog entry name
-
[...]
Any optionalSubsequent arguments to add to the log
info
-
name
-
[...]
Output a info
log entry
Parameters:
-
name
StringLog entry name
-
[...]
Any optionalSubsequent arguments to add to the log


public abstract class Cipher
extends totalcross.lang.Object
If you get a totalcross.crypto.CryptoException: Illegal key size
, you must download the strong cryptography files from Oracle
site. In order to do that, go to the ReadMe file whole link is below the download link. In this file, search for "Unlimited Strength Java
Cryptography Extension" and follow the instructions.
| Modifier and Type | Field and Description |
|---|---|
protected int |
chaining |
static int |
CHAINING_CBC
Constant used to initialize cipher using CBC chaining.
|
static int |
CHAINING_ECB
Constant used to initialize cipher using ECB chaining.
|
static int |
CHAINING_NONE
Constant used to initialize cipher using no chaining.
|
protected byte[] |
iv |
protected Key |
key |
protected Object |
nativeHeap |
protected int |
operation |
static int |
OPERATION_DECRYPT
Constant used to initialize cipher to decrypt.
|
static int |
OPERATION_ENCRYPT
Constant used to initialize cipher to encrypt.
|
protected int |
padding |
static int |
PADDING_NONE
Constant used to initialize cipher using no padding.
|
static int |
PADDING_PKCS1
Constant used to initialize cipher using PKCS #1 padding.
|
static int |
PADDING_PKCS5
Constant used to initialize cipher using PKCS #5 padding.
|
| Constructor and Description |
|---|
Cipher() |
| Modifier and Type | Method and Description |
|---|---|
protected abstract void |
doReset() |
abstract String |
getAlgorithm()
Returns the name of the algorithm.
|
abstract int |
getBlockLength()
Returns the block length.
|
byte[] |
getIV()
Returns the initialization vector (IV) in a new buffer.
|
byte[] |
getOutput()
Finalizes the encryption or decryption operation (depending on how this cipher was initialized) by processing all the accumulated input data
and returning the result in a new buffer.
|
protected abstract boolean |
isChainingSupported(int chaining) |
protected abstract boolean |
isKeySupported(Key key,
int operation) |
protected abstract boolean |
isPaddingSupported(int padding) |
protected abstract byte[] |
process(byte[] data) |
void |
reset(int operation,
Key key)
Initializes this cipher in encryption or decryption mode, without chaining or padding.
|
void |
reset(int operation,
Key key,
int chaining)
Initializes this cipher in encryption or decryption mode, with the given chaining mode and without a padding.
|
void |
reset(int operation,
Key key,
int chaining,
byte[] iv)
Initializes this cipher in encryption or decryption mode, with the given chaining mode, initialization vector and without a padding.
|
void |
reset(int operation,
Key key,
int chaining,
byte[] iv,
int padding)
Initializes this cipher in encryption or decryption mode, with the given chaining
mode, initialization vector padding.
|
String |
toString()
Returns the name of the algorithm.
|
void |
update(byte[] data)
Updates the input data that will be processed by this cipher algorithm.
|
void |
update(byte[] data,
int start,
int count)
Updates the input data that will be processed by this cipher algorithm.
|
void |
update(int data)
Updates the input data that will be processed by this cipher algorithm.
|
protected int operation
protected Key key
protected int chaining
protected byte[] iv
protected int padding
protected Object nativeHeap
public static final int OPERATION_ENCRYPT
public static final int OPERATION_DECRYPT
public static final int CHAINING_NONE
public static final int CHAINING_ECB
public static final int CHAINING_CBC
public static final int PADDING_NONE
public static final int PADDING_PKCS1
public static final int PADDING_PKCS5
public final String toString()
public final byte[] getIV()
null
if the underlying algorithm does not use an IV, or if the IV has not
been set yet.public final void reset(int operation, Key key) throws CryptoException
operation
- The operation mode of this cipher (OPERATION_ENCRYPT
or OPERATION_DECRYPT
).key
- The key.CryptoException
- If one or more initialization parameters are invalid or the cipher fails to initialize with the given parameters.public final void reset(int operation, Key key, int chaining) throws CryptoException
operation
- The operation mode of this cipher (OPERATION_ENCRYPT
or OPERATION_DECRYPT
).key
- The key.chaining
- The chaining mode of this cipher (CHAINING_NONE
, CHAINING_ECB
, or
CHAINING_CBC
).CryptoException
- If one or more initialization parameters are invalid or the cipher fails to initialize with the given parameters.public final void reset(int operation, Key key, int chaining, byte[] iv) throws CryptoException
operation
- The operation mode of this cipher (OPERATION_ENCRYPT
or OPERATION_DECRYPT
).key
- The key.chaining
- The chaining mode of this cipher (CHAINING_NONE
, CHAINING_ECB
, or
CHAINING_CBC
).iv
- The initialization vector.CryptoException
- if one or more initialization parameters are invalid or the cipher fails to initialize with the given parameters.public final void reset(int operation, Key key, int chaining, byte[] iv, int padding) throws CryptoException
operation
- The operation mode of this cipher (OPERATION_ENCRYPT
or OPERATION_DECRYPT
).key
- The key.chaining
- The chaining mode of this cipher (CHAINING_NONE
, CHAINING_ECB
, or
CHAINING_CBC
).iv
- The initialization vector.padding
- The padding mode of this cipher (PADDING_NONE
, PADDING_PKCS1
, or PADDING_PKCS5
).CryptoException
- if one or more initialization parameters are invalid or the cipher fails to initialize with the given parameters.public final void update(int data)
getOutput()
is finally called.data
- The input data.public final void update(byte[] data)
getOutput()
is finally called.data
- The input data.public final void update(byte[] data, int start, int count)
getOutput()
is finally called.data
- The input data.start
- The offset in data
where the data starts.count
- The input length.public byte[] getOutput() throws CryptoException
CryptoException
public abstract String getAlgorithm()
public abstract int getBlockLength()
protected abstract void doReset() throws NoSuchAlgorithmException, CryptoException
protected abstract byte[] process(byte[] data) throws CryptoException
CryptoException
protected abstract boolean isKeySupported(Key key, int operation)
protected abstract boolean isChainingSupported(int chaining)
protected abstract boolean isPaddingSupported(int padding)


First name is required.
Last name is required.
At least one role is required.
Aadhaar No is required.
Phone Number is required.
At least one type is required.


Society of Physics Students
Undergraduate physics club @ UCLA |
Facebook
|
Twitter
Toggle navigation
SPS
Home
Updates
About
Gallery
Officers
2016-2017
2015-2016
2014-2015
Documents
•Arduino
•Logistics
<
[1] Arduino workshop introduction presentation
Link to Google slide
[2] Arduino Whack-A-Mole! code:
Link to source code


(function(root, factory) {
if (typeof define === 'function' && define.amd) {
define(['underscore', 'jquery'], factory);
} else if (typeof exports === 'object') {
module.exports = factory(require('underscore'), require('jquery'));
} else {
root.Torso = root.Torso || {};
root.Torso.Mixins = root.Torso.Mixins || {};
root.Torso.Mixins.cache = factory(root._, (root.jQuery || root.Zepto || root.ender || root.$));
}
}(this, function(_, $) {
var fetchIdentifier = 0;
/**
* Custom additions to the Backbone Collection object.
* - safe disposal methods for memory + event management
* - special functional overrides to support ID registration for different views
*
* @module Torso
* @namespace Torso.Mixins
* @class cacheMixin
* @author<EMAIL_ADDRESS><EMAIL_ADDRESS>*/
var mixin = function(base) {
var cacheMixin, createRequesterCollectionClass;
/**
* Returns a new class of collection that inherits from the parent but not the cacheMixin
* and adds a requesterMixin that connects this cache to it's parent
*
* @method createRequesterCollectionClass
* @param parent {Backbone Collection instance} the parent of the private collection
* @param guid {String} the unique code of the owner of this private collection
*/
createRequesterCollectionClass = function(parent, guid) {
return parent.constructor.extend((function(parentClass, parentInstance, ownerKey) {
/**
* A mixin that overrides base collection methods meant for cache's and tailors them
* to a requester.
* @method requesterMixin
*/
var requesterMixin = {
/**
* @method requesterMixin.getTrackedIds
* @return {Array} array of ids that this collection is tracking
*/
getTrackedIds: function() {
return this.trackedIds;
},
/**
* Will force the cache to fetch just the registered ids of this collection
* @method requesterMixin.fetch
* @param [options] - argument options
* @param [options.idsToFetch=collectionTrackedIds] {Array} - A list of request Ids, will default to current tracked ids
* @param [options.setOptions] {Object} - if a set is made, then the setOptions will be passed into the set method
* @return {Promise} promise that will resolve when the fetch is complete
*/
fetch: function(options) {
options = options || {};
options.idsToFetch = options.idsToFetch || this.trackedIds;
options.setOptions = options.setOptions || {remove: false};
return this.__loadWrapper(function() {
if (options.idsToFetch && options.idsToFetch.length) {
return parentInstance.fetchByIds(options);
} else {
return $.Deferred().resolve().promise();
}
});
},
/**
* Will force the cache to fetch a subset of this collection's tracked ids
* @method requesterMixin.fetchByIds
* @param ids {Array} array of model ids
* @param [options] {Object} if given, will pass the options argument to this.fetch. Note, will not affect options.idsToFetch
* @return {Promise} promise that will resolve when the fetch is complete
*/
fetchByIds: function(ids, options) {
options = options || {};
options.idsToFetch = _.intersection(ids, this.getTrackedIds());
return this.fetch(options);
},
/**
* Pass a list of ids to begin tracking. This will reset any previous list of ids being tracked.
* Overrides the Id registration system to route via the parent collection
* @method requesterMixin.trackIds
* @param ids The list of ids that this collection wants to track
*/
trackIds: function(ids) {
this.remove(_.difference(this.trackedIds, ids));
parentInstance.registerIds(ids, ownerKey);
this.trackedIds = ids;
},
/**
* Adds a new model to the requester collection and tracks the model.id
* @method requesterMixin.addModelAndTrack
* @param model {Backbone Model} the model to be added
*/
addModelAndTrack: function(model) {
this.add(model);
parentInstance.add(model);
this.trackNewId(model.id);
},
/**
* Tracks a new id
* @method requesterMixin.trackNewId
* @param id {String or Number} the id attribute of the model
*/
trackNewId: function(id) {
this.trackIds(this.getTrackedIds().concat(id));
},
/**
* Will begin tracking the new ids and then ask the cache to fetch them
* This will reset any previous list of ids being tracked.
* @method requesterMixin.trackAndFetch
* @return the promise of the fetch by ids
*/
trackAndFetch: function(newIds) {
this.trackIds(newIds);
return this.fetch();
},
/**
* Will force the cache to fetch any of this collection's tracked models that are not in the cache
* while not fetching models that are already in the cache. Useful when you want the effeciency of
* pulling models from the cache and don't need all the models to be up-to-date.
*
* If the ids being fetched are already being fetched by the cache, then they will not be re-fetched.
*
* The resulting promise is resolved when ALL items in the process of being fetched have completed.
* The promise will resolve to a unified data property that is a combination of the completion of all of the fetches.
*
* @method requesterMixin.pull
* @param [options] {Object} if given, will pass the options argument to this.fetch. Note, will not affect options.idsToFetch
* @return {Promise} promise that will resolve when the fetch is complete with all of the data that was fetched from the server.
* Will only resolve once all ids have attempted to be fetched from the server.
*/
pull: function(options) {
options = options || {};
//find ids that we don't have in cache and aren't already in the process of being fetched.
var idsNotInCache = _.difference(this.getTrackedIds(), _.pluck(parentInstance.models, 'id'));
var idsWithPromises = _.pick(parentInstance.idPromises, idsNotInCache);
// Determine which ids are already being fetched and the associated promises for those ids.
options.idsToFetch = _.difference(idsNotInCache, _.uniq(_.flatten(_.keys(idsWithPromises))));
var thisFetchPromise = this.fetch(options);
// Return a promise that resolves when all ids are fetched (including pending ids).
var allPromisesToWaitFor = _.flatten(_.values(idsWithPromises));
allPromisesToWaitFor.push(thisFetchPromise);
var allUniquePromisesToWaitFor = _.uniq(allPromisesToWaitFor);
return $.when.apply($, allUniquePromisesToWaitFor)
// Make it look like the muliple promises was performed by a single request.
.then(function() {
// collects the parts of each ajax call into arrays: result = { [data1, data2, ...], [textStatus1, textStatus2, ...], [jqXHR1, jqXHR2, ...] };
var result = _.zip(arguments);
// Flatten the data so it looks like the result of a single request.
var resultData = result[0];
var flattenedResultData = _.flatten(resultData);
return flattenedResultData;
});
},
/**
* Will register the new ids and then pull in any models not stored in the cache. See this.pull() for
* the difference between pull and fetch.
* @method requesterMixin.trackAndPull
* @return the promise of the fetch by ids
*/
trackAndPull: function(newIds) {
this.trackIds(newIds);
return this.pull();
},
/**
* Handles the disposing of this collection as it relates to a requester collection.
* @method requesterMixin.requesterDispose
*/
requesterDispose: function() {
parentInstance.removeRequester(ownerKey);
}
};
return requesterMixin;
})(parent.constructor.__super__, parent, guid));
};
/**
* Adds functions to manage state of requesters
* @method cacheMixin
* @param collection {Collection} the collection to add this mixin
*/
cacheMixin = function(collection) {
//************* PRIVATE METHODS ************//
/**
* @private
* @method cacheMixin.setRequestedIds
* @param guid {String} the global unique identifier for the requester
* @param array {Array} the array of ids the requester wants
*/
var setRequestedIds = function(guid, array) {
collection.requestMap[guid] = {
array: array,
dict: _.object(_.map(array, function(id) { return [id, id]; }))
};
};
//*********** PUBLIC METHODS ************//
/**
* @method cacheMixin.getRequesterIds
* @param {String} the global unique id of the requester
* @return {Array} an array of the ids the requester with the guid has requested
*/
collection.getRequesterIds = function(guid) {
return this.requestMap[guid] && this.requestMap[guid].array;
};
/**
* @method cacheMixin.getRequesterIdsAsDictionary
* This method is used for quick look up of a certain id within the list of requested ids
* @param guid {String} the global unique id of the requester
* @return {Object} an dictionary of id -> id of the requester ids for a given requester.
*/
collection.getRequesterIdsAsDictionary = function(guid) {
return this.requestMap[guid] && this.requestMap[guid].dict;
};
/**
* @method cacheMixin.removeRequester
* Removes a requester from this cache. No longer receives updates
* @param guid {String} the global unique id of the requester
*/
collection.removeRequester = function(guid) {
delete this.requestMap[guid];
delete this.knownPrivateCollections[guid];
};
/**
* NOTE: this methods returns only the guids for requester collections that are currently tracking ids
* TODO: should this return just the knownPrivateCollections
* @method cacheMixin.getRequesters
* @return {Array} an array of the all requesters in the form of their GUID's
*/
collection.getRequesters = function() {
return _.keys(this.requestMap);
};
/**
* Return the list of Ids requested by this collection
* @method cacheMixin.getAllRequestedIds
* @return {Array} the corresponding requested Ids
*/
collection.getAllRequestedIds = function() {
return this.collectionTrackedIds;
};
/**
* Used to return a collection of desired models given the requester object.
* Binds a custom "resized" event to the private collections.
* Overrides the fetch method to call the parent collection's fetchByIds method.
* Overrides the registerIds method to redirect to its parent collection.
* @method cacheMixin.createPrivateCollection
* @param guid {String} Identifier for the requesting view
* @return {Collection} an new empty collection of the same type as "this"
*/
collection.createPrivateCollection = function(guid, args) {
args = args || {};
args.isRequester = true;
args.parentInstance = collection;
var RequesterClass = createRequesterCollectionClass(collection, guid);
this.knownPrivateCollections[guid] = new RequesterClass(null, args);
return this.knownPrivateCollections[guid];
};
/**
* Registers a list of Ids that a particular object cares about and pushes
* any cached models its way.
*
* This method intelligently updates the "_requestedIds" field to contain all unique
* requests for Ids to be fetched. Furthermore, the "polledFetch" method
* is overriden such that it no longer routes through Backbone's fetch all,
* but rather a custom "fetchByIds" method.
* @method cacheMixin.registerIds
* @param newIds {Array} - New ids to register under the requester
* @param guid {String} - The GUID of the object that wants the ids
*/
collection.registerIds = function(newIds, guid) {
var i, newIdx, model, requesterIdx, storedIds,
requesters, requesterLength, privateCollection,
models = [],
distinctIds = {},
result = [];
// Save the new requests in the map
setRequestedIds(guid, newIds);
requesters = collection.getRequesters();
requesterLength = requesters.length;
// Collect all cached models
for (newIdx = 0; newIdx < newIds.length; newIdx++) {
model = collection.get(newIds[newIdx]);
if (model) {
models.push(model);
}
}
// Push cached models to the respective requester
privateCollection = collection.knownPrivateCollections[guid];
privateCollection.set(models, {remove: false});
// Create a new request list
for (requesterIdx = 0; requesterIdx < requesterLength; requesterIdx++) {
storedIds = this.getRequesterIds(requesters[requesterIdx]);
if (!_.isUndefined(storedIds)) {
for (i = 0; i < storedIds.length; i++) {
distinctIds[storedIds[i]] = true;
}
}
}
// Convert the hash table of unique Ids to a list
for (i in distinctIds) {
result.push(i);
}
this.collectionTrackedIds = result;
// Overrides the polling mixin's fetch method
this.polledFetch = function() {
collection.fetchByIds({
setOptions: {remove: true}
});
};
};
/**
* Overrides the base fetch call if this.fetchUsingTrackedIds is true
* Calling fetch from the cache will fetch the tracked ids if fetchUsingTrackedIds is set to true, otherwise
* it will pass through to the default fetch.
* @method fetch
*/
collection.fetch = function(options) {
options = options || {};
if (this.fetchUsingTrackedIds) {
return this.fetchByIds({
setOptions: _.extend({remove: true}, options)
});
} else {
return base.prototype.fetch.apply(this, options);
}
};
/**
* A custom fetch operation to only fetch the requested Ids.
* @method cacheMixin.fetchByIds
* @param [options] - argument options
* @param [options.idsToFetch=collection.collectionTrackedIds] {Array} - A list of request Ids, will default to current tracked ids
* @param [options.setOptions] {Object} - if a set is made, then the setOptions will be passed into the set method
* @return {Promise} the promise of the fetch
*/
collection.fetchByIds = function(options) {
var fetchId = fetchIdentifier++;
options = options || {};
// Fires a method from the loadingMixin that wraps the fetch with events that happen before and after
var requestedIds = options.idsToFetch || collection.collectionTrackedIds;
var fetchComplete = false;
var fetchPromise = this.__loadWrapper(function(options) {
var contentType = options.fetchContentType || collection.fetchContentType;
var ajaxOpts = {
type: collection.fetchHttpAction,
url: _.result(collection, 'url') + collection.getByIdsUrl,
data: {ids: requestedIds.join(',')}
};
if (contentType || (ajaxOpts.type && ajaxOpts.type.toUpperCase() != 'GET')) {
ajaxOpts.contentType = contentType || 'application/json; charset=utf-8';
ajaxOpts.data = JSON.stringify(requestedIds);
}
return $.ajax(ajaxOpts)
.done(function(data) {
var i, requesterIdx, requesterIdsAsDict, models, privateCollection,
requesterLength, requesters, model,
requestedIdsLength = requestedIds.length,
setOptions = options.setOptions;
collection.set(collection.parse(data), setOptions);
// Set respective collection's models for requested ids only.
requesters = collection.getRequesters();
requesterLength = requesters.length;
// For each requester...
for (requesterIdx = 0; requesterIdx < requesterLength; requesterIdx++) {
requesterIdsAsDict = collection.getRequesterIdsAsDictionary(requesters[requesterIdx]);
models = [];
// ... now let's iterate over the ids that were fetched ...
for (i = 0; i < requestedIdsLength; i++) {
//if the id that the requester cares about matches that model whose id was just fetched...
if (requesterIdsAsDict[requestedIds[i]]) {
model = collection.get(requestedIds[i]);
// if the model was removed, no worries, the parent won't attempt to update the child on that one.
if (model) {
models.push(model);
}
}
}
privateCollection = collection.knownPrivateCollections[requesters[requesterIdx]];
// a fetch by the parent will not remove a model in a requester collection that wasn't fetched with this call
privateCollection.set(models, {remove: false});
}
});
}, options)
.always(function() {
// This happens once the promise is resolved, and removes the pending promise for that id.
// Track that the fetch was completed so we don't add a dead promise (since this is what cleans up completed promises).
fetchComplete = true;
// Note that an id may have mulitple promises (if fetch was called multiple times and then a pull with the same id).
// We want to wait for all of them to complete, this tracks them separately and removes the in-flight promises once they are done.
_.each(requestedIds, function(requestedId) {
if (collection.idPromises) {
var existingPromisesForId = collection.idPromises[requestedId];
var remainingPromisesForId = _.without(existingPromisesForId, fetchPromise);
if (_.isEmpty(remainingPromisesForId)) {
delete collection.idPromises[requestedId];
} else {
collection.idPromises[requestedId] = remainingPromisesForId;
}
}
});
});
// Track the promises associated with each id so we know when that id has completed fetching.
// Multiple simultaneous pulls will generate multiple promises for a shared id.
// Pulls will not generate new promises for the given ids (if there are ids being fetched
if (!fetchComplete) { // fixes the sync case (mainly during tests when mockjax is used).
_.each(requestedIds, function(requestedId) {
var existingPromises = collection.idPromises[requestedId];
if (!existingPromises) {
existingPromises = [];
collection.idPromises[requestedId] = existingPromises;
}
existingPromises.push(fetchPromise);
});
}
return fetchPromise;
};
};
return {
/**
* The constructor constructor / initialize method for collections.
* Allocate new memory for the local references if they
* were null when this method was called.
* @param [options] {Object} - optional options object
* @param [options.fetchHttpAction='POST'] {String} http action used to get objects by ids
* @param [options.getByIdsUrl='/ids'] {String} path appended to collection.url to get objects by a list of ids
* @param [options.fetchUsingTrackedIds=true] {Boolean} if set to false, cache.fetch() will not pass to fetchByIds with current tracked ids
but will rather call the default fetch method.
* @method constructor
*/
constructor: function(models, options) {
options = options || {};
base.call(this, models, options);
this.isRequester = options.isRequester;
this.parentInstance = options.parentInstance;
if (!this.isRequester) {
this.requestMap = {};
this.collectionTrackedIds = [];
this.knownPrivateCollections = {};
this.idPromises = {};
var cacheDefaults = _.defaults(
_.pick(options, 'getByIdsUrl', 'fetchHttpAction', 'fetchUsingTrackedIds'),
_.pick(this, 'getByIdsUrl', 'fetchHttpAction', 'fetchUsingTrackedIds'),
{
getByIdsUrl: '/ids',
fetchHttpAction: 'GET',
fetchUsingTrackedIds: true
}
);
_.extend(this, cacheDefaults);
cacheMixin(this);
} else {
this.trackedIds = [];
this.listenTo(this.parentInstance, 'load-begin', function() {
this.trigger('cache-load-begin');
});
this.listenTo(this.parentInstance, 'load-complete', function() {
this.trigger('cache-load-complete');
});
}
},
};
};
return mixin;
}));


FreeBSD/ppc Project
Introduction
The FreeBSD/ppc project pages contain information about the FreeBSD port to the PowerPC architecture. As with the port itself, these pages are still a work in progress.
Table Of Contents
- Status
- Latest News
- Port FASQs
- Supported Hardware
- FreeBSD/ppc mailing list
- Known Issues
- Documentation, White Papers, Utilities
- Other links of interest
Status
The FreeBSD/ppc port is still a Tier 2 platform. That means it is not being fully supported by our security officer, release engineers and toolchain maintainers.
Latest News
- 03 April, 2009: Support for the PowerPC G5 has been committed to SVN.
- 03 March, 2008: Support for Freescale PowerQUICC III MPC85XX family system-on-chip development boards has been committed into CVS.
- 27 February, 2008: FreeBSD 7.0 is the first release to officially support the FreeBSD/ppc port.
Frequently Asked Questions
How can I install FreeBSD/ppc?
ISO images of FreeBSD 8.2 suitable for New-World Macs are available for download, for details on how to obtain these see the release announcement. Please follow instructions given here.


class NightModeInstance
Wrapper for NightModeEnum and it's correct language translation.
NightModeInstance(string: String, enum: NightModeEnum)
Wrapper for NightModeEnum and it's correct language translation. |
val enum: NightModeEnum |
|
val string: String |
fun toString(): String |