Class CompilerTests
The compiler tests.
Inheritance
Namespace: Tests
Assembly: Tests.dll
Syntax
public class CompilerTests : object
Constructors
View SourceCompilerTests()
Initializes a new instance of the CompilerTests class.
Declaration
public CompilerTests()
Methods
View SourceCompileAndRunActionCommandTest()
Given: I have valid c# commands When: I compile it Then: I should be able to call it multiple times without recompiling and retrieve the globals
Declaration
public Task CompileAndRunActionCommandTest()
Returns
| Type | Description |
|---|---|
| Task | The |
CompileAndRunCommandTest()
Given: I have valid c# commands When: I compile it Then: I should be able to call it multiple times without recompiling
Declaration
public Task CompileAndRunCommandTest()
Returns
| Type | Description |
|---|---|
| Task | The |
CompileAndRunWithParametersCommandTest()
Given: I have a c# commands that will return a subset of an existing list depending on its context When: I compile it Then: I should be able to call it multiple times without recompiling and receive the correct response for each context
Declaration
public Task CompileAndRunWithParametersCommandTest()
Returns
| Type | Description |
|---|---|
| Task | The |
CompilingCommandFailsTest()
Given: I have a invalid c# commands When: I compile it Then: I should receive an
Declaration
public void CompilingCommandFailsTest()
CompilingEmptyCommandFailsTest()
Given: I have an empty c# commands When: I compile it Then: I should receive an
Declaration
public void CompilingEmptyCommandFailsTest()
RunCommandFailsTest()
Given: I have an invalid c# command that will return a subset of an existing list When: I execute it Then: I should receive an compilation exception
Declaration
public void RunCommandFailsTest()
RunCommandListFailsTest()
Given: I have a list of invalid c# commands that will return a subset of an existing list When: I execute it Then: I should receive an CompilationErrorException
Declaration
public void RunCommandListFailsTest()
RunCommandListTest()
Given: I have a list of valid c# commands that will return a subset of an existing list When: I execute it Then: I should receive the correct number of items in the list
Declaration
public Task RunCommandListTest()
Returns
| Type | Description |
|---|---|
| Task | The |
RunCommandListWithParametersFailsTest()
Given: I have a list of invalid c# commands that will return a subset of an existing list and a context object that will be used during execution When: I execute it Then: I should receive an NoCodeToCompileException
Declaration
public void RunCommandListWithParametersFailsTest()
RunCommandListWithParametersTest()
Given: I have a list of valid c# commands that will return a subset of an existing list and a context object that will be used during execution When: I execute it Then: I should receive the correct number of items in the list
Declaration
public Task RunCommandListWithParametersTest()
Returns
| Type | Description |
|---|---|
| Task | The |
RunCommandTest()
Given: I have a c# command that will return a subset of an existing list When: I execute it Then: I should receive the correct number of items in the list
Declaration
public Task RunCommandTest()
Returns
| Type | Description |
|---|---|
| Task | The |
RunCommandWithParametersFailsTest()
Given: I have an invalid c# command that will return a subset of an existing list with a context object that will be used during execution When: I execute it Then: I should receive a CompilationErrorException
Declaration
public void RunCommandWithParametersFailsTest()
RunCommandWithParametersTest()
Given: I have a c# command that will return a subset of an existing list with a context object that will be used during execution When: I execute it Then: I should receive an exception
Declaration
public Task RunCommandWithParametersTest()
Returns
| Type | Description |
|---|---|
| Task | The |
RunEmptyCommandFailsTest()
Given: I have an empty c# command that will return a subset of an existing list When: I execute it Then: I should receive an NoCodeToCompileException exception
Declaration
public void RunEmptyCommandFailsTest()
RunEmptyCommandListFailsTest()
Given: I have an empty command When: I execute it Then: I should receive an NoCodeToCompileException exception
Declaration
public void RunEmptyCommandListFailsTest()
RunEmptyCommandListWithParametersFailsTest()
Given: I have an empty list of invalid c# commands and a context object that will be used during execution When: I execute it Then: I should receive an NoCodeToCompileException
Declaration
public void RunEmptyCommandListWithParametersFailsTest()
RunEmptyCommandWithParametersFailsTest()
Given: I have an empty c# command that will return a subset of an existing list with a context object that will be used during execution When: I execute it Then: I should receive a CompilationErrorException
Declaration
public void RunEmptyCommandWithParametersFailsTest()
RunPreCompiledScriptWithParametersCommandTest(Int32, Int32)
Given: I have a pre-compiled script that will return a subset of an existing list depending on its context When: I execute it Then: I should be able to call it multiple times without recompiling and receive the correct response for each context
Declaration
public Task RunPreCompiledScriptWithParametersCommandTest(int take, int expectedResult)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | take | Number of items to take from the list |
| System.Int32 | expectedResult | The expected Result. |
Returns
| Type | Description |
|---|---|
| Task | The |


WebGL renderer for Vega
airports
arc
area
bar-hover-label
bar
barley
budget-forecasts
chart-rangestep
chart
choropleth
crossfilter-multi
crossfilter
dimpvis
driving
error
falkensee
force-beeswarm
force-network
gradient
grouped-bar
heatmap-lines
heatmap
histogram
horizon
images
jobs
legends
lifelines
map-bind
map
matrix-reorder
nested-plot
overview-detail
panzoom
parallel-coords
playfair
population
scale
scatter-plot
shift-select
splom-inner
splom-outer
stacked-area
stacked-bar
stocks-index
tree-radial
treemap
violin-plot
weather
wordcloud
webgl
canvas
svg
rotate
bounce
This
code
is built and maintained by the
Kitware
Resonant
team in collaboration with the
UW Interactive Data Lab
. The work is supported by the DARPA AFRL
XDATA
program.


Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
This document is a glossary of terms recurrent in the Model-based User Interface domain (MBUI). It is intended to capture a common, coherent terminology for specifications of the MBUI Working Group and to provide a concise reference of domain terms for interested audience. The document arose from a thorough review and discussion of the glossaries published by the CAMELEON and AMODEUS research projects.
This document was published by the MBUI working group and defines a glossary of terms for use within specifications of the MBUI Working Group.If you wish to make comments regarding this document, please send them to<EMAIL_ADDRESS>(subscribe, archives). All comments are welcome.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
W3C recommended term: Abstract Interaction Unit.
(a) Interaction unit that is independent from the interaction modalities and from the implementation technology.
(b) Component of an Abstract User Interface (AUI).
Synonyms: Abstract interactor, Abstract Interaction Object, Presentation Unit.
W3C recommended term: Abstract Interaction Unit.
Composite task whose subtasks categories are different (i.e. a mix of any of the following: user task, system task, interaction task and abstract task).
(a) Composition of Abstract Interaction Units along with their abstract behaviour.
(b) Metonymic use for Abstract User Interface model.
Transformation of a model into a different model whose semantic content and scope are higher than the content and scope of the original model.
Comment: opposite of Concretization.
Ability of a UI to adapt as a result of an explicit human intervention according to a set of predefined options.
Synonyms: Customizability.
UI that supports Adaptability.
UI that supports Adaptivity.
Ability of a UI to adapt itself without any explicit human intervention.
W3C recommended term: System task.
Task that modifies the state of the user interface without modifying the domain-dependent state. Examples are: "scroll", "zoom", "page navigation".
The ability of the interactive system to provide articulatory tasks to make observable the system state that is relevant in the current situation.
Domain-dependent concept whose relevance for the user is key (to accomplish a particular task - or a set of tasks, in a particular context of use - or set of contexts of use). It should be directly observable.
Task that can be decomposed into sub-tasks.
Opposite of Abstraction.
W3C recommended term: Concrete Interaction Unit.
(a) Interaction unit that is defined in terms of some interaction modality and independently from any implementation technology.
(b) Component of a Concrete User Interface (CUI). Examples include: Radio button, drop-down menu, input field
Synonyms: Concrete interactor, Concrete Interaction Object.
W3C recommended term: Concrete Interaction Unit.
(a) Composition of Concrete Interaction Units along with their concrete behaviour.
(b) Metonymic use for Concrete User Interface model.
In the area of user interface design and development, metonymic use for Context of use.
User interface that supports context awareness.
Ability of an interactive system to detect (changes in) the context of use and to identify changes that are relevant.
Relevant information used at design time and/or at run time about the following:
(1) the user (or set of users) who is (are) intended to use, or is actually using, the interactive system (e.g., capabilities/functional limitations, preferences/needs, profile, idiosyncrasies, current tasks and activities, role);
(2) the platform to be used or is actually used;
(3) the social and physical environment (or set of environments) when/where the interaction will take place, or is actually taking place. This includes numeric and/or symbolic times and locations (e.g., in the morning, at 4 o'clock, at home, in a public space, on the move in the street, in the train or car), social rules and activities, light, temperature, sound, etc., conditions.
Context aware UI that is able to react to changes of the context of use.
Transformation of a model into another model at a different level of abstraction (higher or lower), while changing the context of use.
W3C recommended term: Adaptability.
An apparatus incorporating, or managing, a collection of peripherals, and which appears to a user as a functional unit through which to perform an interaction process. A device can include computational abilities, act as a stand-alone interactive system, or be part of a network. Examples include iPhone 4, Samsung Galaxy III, MS Kinect, Wii...
Allocation of user interface components across devices. The granularity for distribution may be one of (in decreasing order): application level (e.g., full replication of the UI on different devices), Abstract Interaction Unit level, domain concept level, or even portions of Concrete Interaction Units.
Distributed user interfaces allow access to an application through multiple devices at a given time.
The field of interest with respect to which an interactive application is developed.
Synonyms: Application domain.
Concept relevant to users to accomplish tasks in a particular application area.
Synonyms: Domain object.
Set of domain concepts and their relationships.
W3C recommended term: Domain concept
Device that cannot be decomposed, i.e. if it were decomposed, it would not function as a computational unit anymore. Examples include personal computers, tablets, or mobile phones.
Task that is not decomposed into subtasks.
Any level of abstraction in the transformation process from which the development of a UI is initiated.
Metonymic use for physical and social environment.
W3C recommended term: Final User Interface.
(a) Source code of a UI, in any programming language or markup language (e.g., Java, HTML5, VoiceXML) that can be interpreted or executed.
(b) Metonymic use for FUI model.
Synonyms: Executable User Interface.
Process of developing a software product. The opposite of reverse engineering.
Process by which two or more systems are coupled so that they reciprocally influence each other's state or behaviour. When at least one of the systems is a human being, and one is a computational system we speak of Human-Computer Interaction.
Synonyms: Interaction resource, physical device.
Language used by the user or the system for interacting. A language defines the set of all possible well-formed expressions, i.e. the conventional assembly of symbols, that convey meaning.
(a) Type of communication channel to acquire (input modality) or convey information (output modality) in an interaction between a user and an interactive system.
(b) Coupling of an interaction device peripheral with an interaction language.
Comment: the couple <pen, pseudo-natural language>
and <keyboard, pseudo-natural language>
are two interaction modalities (they use the same interaction language but two distinct input devices peripherals).
Interaction device used by the user to manipulate and/or observe the state of an interactive system. Examples include screens, keyboard, mouse, real world objects (such as phicons).
A collection of interactors that support the execution of a set of logically/semantically connected tasks. In graphical user interfaces, an interaction space can be mapped onto a window, a set of panels, or generally a container of some sort.
Synonyms: Workspace, presentation unit
Task performed by the user to modify and/or observe the state of the interactive system (e.g., editing, selecting from an item list, filtering, scrolling and zooming).
An entity that supports a task or a set of sub-tasks that are logically related to achieve a goal (or a set of goals).
A computational system that supports a set of tasks with the participation of one or more humans by the way of interactions between this system and these humans.
An element of a user interface that embodies particular interaction semantics (e.g.text input, single choice) or functionality (e.g. grouping, navigation). It allows users to observe and/or manipulate domain concepts and functions by means of interaction resources. Depending on the level of abstraction an interactor might specify a concrete appearance.
(a) Layer within a system whose information types are characterized by a given semantic content and scope. The lowest level of abstraction corresponds to the poorest information type with regard to scope and content. The highest level of abstraction corresponds to the richest information type with regard to scope and content. These levels as well as any level in-between depend on the perspective or the objective of the modeler and/or the modeling technique.
(b) Different perspectives in the development process of a system.
Correspondence between elements of a source model and elements of a target model. For example, for traceability purpose, the correspondence between a source task and its target AIU(s) can be maintained as a mapping function.
Model that sets the rules and the constraints for producing the construction of models. As such, it is defines a set of models that comply with it.
Comment: a model complies to a single meta-model, whereas a meta-model may have many compliant models.
Transfer of all, or parts, of the user interface between different devices. May occur at run time or between sessions.
Migratory user interfaces can move to a different device while preserving their state across the devices involved.
(a) Metonymic use for interaction modality.
(b) Can be perceived by one of the human perceptual senses.
Any representation of a real or imagined system or entity for a particular purpose. In the context of MBUID, a model is any representation of a real or imagined aspect of an interactive software for the purpose of user interface development.
Multi-device user interfaces can be accessed through multiple devices.
Comment: this is a general category, which includes various non-exclusive subcases, such as distributed UIs, migratory UIs, and still others. There are user interfaces that are both distributed and migratory, others that belong to only one of these two categories, and others that are neither distributed nor migratory (e.g. responsive design).
UI that supports multi-modality.
Capability of an interactive system to support multi-modal interaction, i.e., the user is provided with more than one modality (simultaneously or not) to observe the system state and/or can use more than one modality (simultaneously or not) to communicate information to the system.
Multiple contexts of use considered at design time for UI development.
User interface that supports multiple targets (i.e., multiple types of users, platforms and environments).
Interactive system that supports mobile users.
Ability of the interactive system to make perceivable the system state that is relevant in the current situation.
Comment: central domain concepts should be observable. If this is not possible (due to insufficient interaction resources), then they should be browsable.
A physical or virtual component of an interactive system through which input and/or output occur. Depending on its role, a peripheral can be a sensor or an effector. Examples include actual or virtual keyboard, loudspeaker, pen, mouse, motion sensors. A peripheral is usually embodied into, or connected with, a device, which is responsible for its management.
Physical and social setting where the interaction takes place or will take place effectively. It is the set of objects, persons and events that are peripheral to the current activity but that may have an impact on the system and/or users behaviour. Examples of environmental dimensions are physical conditions (lighting, surrounding noise, time, location), social conditions (stress, group dynamics, private ou public spaces), and organizational conditions (hierarchy, user's role).
Synonyms: Environment.
Description of the Physical and social environment.
Synonyms: Environment model.
User interface that supports plasticity.
Ability of a UI to adapt to different contexts of use while preserving worth for users.
An integrated collection of software and/or hardware technologies and/or resource specifications, which defines specific constraints on, and possibly supports, the implementation of an interactive system and/or of devices for interacting with it. Examples are the Smartphone, Android Smartphone, the Tablet, the Desktop...
Ability of a system to run on systems defined under different platforms without modifying the source code of this system.
(a) Information provided by the user interface at a given time.
(b) Process of rendering information.
Property that allows that some state or set of states can be reached from a given state through user's physical actions on interaction with the system.
Operation that transforms a model into another one at the same level of abstraction for the same context of use.
W3C recommended term: Concretization.
Ability of the system to offer alternative representations for a domain concept.
(a) Analysis of a software system so that the software is more understandable for maintenance, evolution, and re-engineering purposes.
(b) Analysis of a system to identify its components and their dependencies to extract and create system abstractions and design information. The original system is not altered. However, additional knowledge about the system is produced. Opposite of forward engineering.
Ability of the UI to prevent users and system errors, as well as the ability of the UI to increase the chance of successful task accomplishment.
Users tend to follow various tasks in parallel. Whereas some tasks can be accomplished in short term, long term tasks might be interrupted by more important ones and continued later on. A session management allows handling of interruptions and the possibility to continue tasks later on.
Task executed on behalf of the system (e.g., computation of the results of a query).
Synonyms: Application task.
Metonymic use for Context of use at design time.
Archetypal platform envisioned for the interactive system.
Activity that should be performed in order to reach a goal.
Definition of how the performance of the task is allocated. Task category can be user, system, interactive, abstract.
Description of a set of tasks and their relationships. Relationships can be defined in terms of a hierarchical decomposition of a task into subtasks at different levels of abstraction, or of temporal/causal dependencies/conflicts among subtasks at the same level of abstraction.
Operator that denotes temporal relationships among the executions of tasks.
Set of tasks supported by one presentation.
Indication of the semantic effect obtained by the performance of a task (e.g. selection, show information, etc.).
Community and technology contexts characterized by specific software languages, software technologies, software development methods, knowledge and skills.
Comment: examples include documentware concerned with digital documents expressed in XML, the Java world.
In the context of Model Driven Engineering, production of a set of target models from a set of source models, according to a transformation definition. A transformation definition is a set of transformation rules that together describe how source models are transformed into target models. A set of transformation rules is a model (a transformation model) that complies with a transformation meta-model.
Operation that transforms a model intended for a particular context of use into a model at the same level of abstraction but aimed at a different context of use.
Software components of an interactive system that allow users to observe and manipulate domain-dependent concepts.
Extent to which a product can be used by specified users to achieve specified goals with effectiveness, efficiency and satisfaction in a specified context of use.
Measure of the system resources as well as the human resources the interactor requires.
A human interacting with the interactive system under study.
Task performed by the user without acting on the interactive system explicitly (i.e., an internal cognitive activity, such as selecting a strategy to solve a problem).
W3C recommended term: Abstract Interaction Unit.


IHeartPy!
♥The lovable Python Instructor♥
{{ quotation }} -
{{ quotation_author }}
[^]
{{ notifications }}
Share:
+
f
t
h
Your Badge:
♥
Python Interactive Shell
LOL
theme
print
clear
Python {{ python_version }} """Welcome to IHeartPy! Type python commands below and hit Enter. For inserting a new line: Shift+Enter For Undo or Redo: Use Ctrl+ Up or Down {{ greetings }} Happy coding."""
LOL
theme
print
clear
#Hello


Capital Allocation Monitoring
Markets as weighing machine
“In the short run, the market is a voting machine but in the long run, it is a weighing machine.”
- Benjamin Graham
"In the long run we are all dead." - John Maynard Keynes
How can we filter out the long term signal from short term noise of the stock market? We can gain a deeper understanding of the market by monitoring the capital allocation behavior of the firms in it. Companies differ in how they make money however they are all faced with the same broad choices on how to spend it.
- Organic Growth: Reinvest it back into the firm
- Mergers and Acquisitions: Buy another firm
- Debt Reduction: pay back debt
- Share Buyback: reduce the share count outstanding
- Dividend: pay it out the shareholders
Capital allocation decision are made only at the highest level of the firm. Changes in capital allocation strategy signals to sophisticated either financial stress or new found freedom. The long run price formation process is casually driven by how the shareholder base responds a firm capital allocation decisions. Activist investors actively seek change in their target companies. Dividend investors will sell companies that switches from paying out.
Reading the SEC filings
Public companies are required by law to file any changes in capital allocation with SEC. However the information is stated in natural language. There isn't a standardized form that each company fills out that states clearly its current capital allocation state. Instead analyst and investors read the filings and come to their own conclusion. This means that this signal is completely beyond the read of any trading system that can't process natural language. Fortune reads the SEC filings sentence by sentence to recreate the entire capital allocation history.
Case Study: Dorian LPG
Dorian LPG (NYSE: LPG) is a liquefied petroleum gas shipping company and a leading owner and operator of modern very large gas carriers (“VLGCs”). This company is an ideal case for Fortune to understand capital allocation and long run equity prices. LPG has only been a public company since July 30, 2013. There clear transitions of capital allocation. The entire history can be found on the company's website which allows for easy verification of the system's classification accuracy.
- From 2013 to June 2017, the company was in organic growth state. They sign contracts to purchase new built tankers that take about 2 years to deliver. Facing a declining tanker rate market, this adversely impacted the stock price. See the organic growth section in chart below.
- To prevent further financial distress the company pivoted to debt reduction and restructuring on June 2017. The stock price clearly did not perform with this the management team and capital focusing on paying debt. An unsuccessful hostile take over bid was launch on 6/15/2018 by a competitor BW LPG.
- The tanker rate finally began to recover in the second half of 2019, with impending introduction of IMO 2020 and massive increase in LPG production in US from shale revolution. The company announce a share repurchase program on 8/7/2019. The stock has responded positively since the change in capital allocation strategy.
Of course not every company will have such clear cut story and transition. The chart below shows the timeline that I manually annotated. Interesting thing to note is that the trend and volatility looks distinctly different in each period. You can compare it will NLP generated one by adding LPG as a stock. The underlying classifier still needs plenty of work. However you can try out the system by adding stocks below.
Compare Stocks
Add stocks to view machine annotated timeline. The project still requires work to tune the classification. However having a search engine that indexes sentences and the proper search term for each category helped a lot. Data engineering,taking raw filings storing it a form usable by the NLP, is what made this project possible in 3 weeks.
Text Classification
This classifier is trained on text from SEC filings. Therefore it works best if you phrase sentences like actual corporate press releases. Here are some examples for each capital allocation category taken actual filings:
- Chevron Corporation (NYSE: CVX) announced today that it has entered into a definitive agreement with Anadarko Petroleum Corporation (NYSE: APC) to acquire all of the outstanding shares of Anadarko in a stock and cash transaction valued at $33 billion, or $65 per share.
- On August 5, 2019, our Board of Directors authorized the repurchase of up to $50 million of our common stock through the period ended December 31, 2020.
- These transactions resulted in the removal of approximately $900 million of debt from the company's balance sheet.
- RANGE RESOURCES CORPORATION (NYSE: RRC) today announced that its Board of Directors declared a quarterly cash dividend on its common stock for the fourth quarter.
- Dorian LPG Ltd. (NYSE: LPG) (the "Company" or "Dorian LPG"), a leading owner and operator of modern Very Large Gas Carriers ("VLGCs"), reported that today it took delivery of the ECO VLGC Concorde from Hyundai Heavy Industries.
System Coverage
Trusted users of the system have access to real time dashboards created using Kibana. Below is a screen showing the actual coverage of the system as of 2/6/2020.
About
This is Phat Loc. I hope you enjoyed the website. Please feel free to message me on LinkedIn if you have any questions or feedback. Fortune was create to demonstrate my data engineering skills as part of my time as a data engineering fellow at Insight. The majority the source code can be found at my github repository.


Page 3 - Andromeda
P. 3
How to use The Hidden Library
1. In order to add a new book, first you have to press Register button
and complete the registration.
2. You can delete and edit information about your books but you are not
allowed to operate with other books!
3. Complete all the information about each book in correct form!
4. You can download books for free, without any registration.
5. The administrator can operate with all the books, which includes
editing and deleting!
6. Please, do not add any books without a permission. The author rights
are checked very strictly!
7. For more information you can check About our Project.


In no particular order, here's what peaks Gerald's interest. What you think? Nevermind, lol!!!
You know I found flickr to be a great place to show you my interests. Shall we begin?
There you have it. In a nutshell, these are my interests. Thanks for checking out my page!


Material.
More...
#include <Material.hpp>
Material.
Definition at line 39 of file Material.hpp.
◆ Material()
| Rendering3D::Material::Material |
( |
size_t |
colors_size | ) |
|
|
inline |
Creates an instance with the given size of colors.
- Parameters
-
| colors_size | The size of vertices of the mesh this material is attached to. |
Definition at line 78 of file Material.hpp.
◆ calculate_average_color()
| void Rendering3D::Material::calculate_average_color |
( |
const int * |
first, |
|
|
const int * |
last |
|
) |
| |
|
inline |
Calculate the average color in the given range.
- Parameters
-
| first | The first in range |
| last | The last in range |
Definition at line 118 of file Material.hpp.
◆ get_average_color()
Gets a reference to the average color.
- Returns
- The average color
Definition at line 99 of file Material.hpp.
◆ get_color()
Gets a reference to the diffuse color of the material.
- Returns
- The reference to the diffuse color
Definition at line 90 of file Material.hpp.
◆ get_ka()
| float Rendering3D::Material::get_ka |
( |
| ) |
|
|
inline |
Gets the ambient component factor.
- Returns
- The ambient component factor
Definition at line 137 of file Material.hpp.
◆ get_kd()
| float Rendering3D::Material::get_kd |
( |
| ) |
|
|
inline |
Gets the diffuse component factor.
- Returns
- The diffuse component factor
Definition at line 146 of file Material.hpp.
◆ get_kl()
| float Rendering3D::Material::get_kl |
( |
| ) |
|
|
inline |
Gets the light component factor.
- Returns
- The light component factor
Definition at line 155 of file Material.hpp.
◆ get_transformed_colors()
Gets a reference to the transformed colors collection.
- Returns
- The transformed colors collection
Definition at line 108 of file Material.hpp.
◆ set_color()
Sets the diffuse color.
- Parameters
-
Definition at line 191 of file Material.hpp.
◆ set_ka()
| void Rendering3D::Material::set_ka |
( |
float |
ka | ) |
|
|
inline |
Sets the ambient component factor.
- Parameters
-
| ka | The ambient component factor |
Definition at line 164 of file Material.hpp.
◆ set_kd()
| void Rendering3D::Material::set_kd |
( |
float |
kd | ) |
|
|
inline |
Sets the diffuse component factor.
- Parameters
-
| kd | The diffuse component factor |
Definition at line 173 of file Material.hpp.
◆ set_kl()
| void Rendering3D::Material::set_kl |
( |
float |
kl | ) |
|
|
inline |
Sets the light component factor.
- Parameters
-
| kl | The light component factor |
Definition at line 182 of file Material.hpp.
The documentation for this class was generated from the following file:
- D:/Repositorios/3DRendering/Rendering/code/headers/Material.hpp


BBLog Signature only allows text.
And this is why we can't have nice things :(
Post edited 1 x times, last by
Brady_The
Brady_The
I probably shouldn't throw ideas in here because I have absolutely no clue about development, but wouldn't it be possible to add an option which forwards your getbblog signature to Battlelog? If someone want to use pictures in his Battlelog signature, he had to register an account and create a signature here where a spam protection or restrictions (only x pictures, no videos, etc (don't know if anything like this exists right now)) would step in if an user would overdo it.
Anyway
, it probably doesn't work or is pretty much useless. I just like to throw in my ideas, without being asked, without any clue and totally shameless. I apologize. Lol
BrainFooLong
Administrator
Technically not possible.
The BBLog Signature in the battlelog forums is just a text that be appended on save.


This site is licensed under a Creative Commons License. Please inform us in case you believe there is a copyright infringement with any of the scans publicated via Arachne and we will immediately solve the problem.
The license agreements of the apply to those contents of the Arachne portal and the Arachne object database which are visualised in our website and are only accessible from here. Contents that can merely be accessed in an indirect connection with our web site Arachne (e.g. high-resolution printable scans) are subject to different regulations that do not pertain to the Creative Commons License. These regulations are explained in context with the transaction of images after a purchase or in the contact form.
To order pictures as publication models, refer to the original models for the pictures desired:
The following prices merely refer to the development charges for those cases in which the requested image material is not published, or is published solely for scientific purposes. In all other cases the prices for the right to publish the image can be conveyed after request.
Note: The pictures have to be paid for in advance. The methods of payment are stated on the bill. Unfortunately credit cards can currently not be accepted. Furthermore a voucher copy is requested. The permanent link of the corresponding record is to be used for the list of illustrations. (e.g.: http://arachne.uni-koeln.de/item/marbilder/686810).


User single-shot or periodic timer. More...
#include <cmsis-plus/rtos/os.h>
Classes | |
| class | attributes |
| Timer attributes. More... | |
| class | attributes_periodic |
| Periodic timer attributes. More... | |
| struct | run |
| Timer run types. More... | |
| struct | state |
| Timer states. More... | |
Public Types | |
| using | func_args_t = void * |
| Timer call back function arguments. | |
| using | func_t = void(*)(func_args_t args) |
| Entry point of a timer call back function. | |
| using | state_t = uint8_t |
| Type of of variables holding timer states. | |
| using | type_t = uint8_t |
| Type of of variables holding timer run types. | |
Public Member Functions | |
Constructors & Destructor | |
| timer (func_t function, func_args_t args, const attributes &attr=once_initializer) | |
| Construct a timer object instance. | |
| timer (const char *name, func_t function, func_args_t args, const attributes &attr=once_initializer) | |
| Construct a named timer object instance. | |
| ~timer () | |
| Destruct the timer object instance. | |
Operators | |
| bool | operator== (const timer &rhs) const |
| Compare timers. | |
Public Member Functions | |
| result_t | start (clock::duration_t period) |
| Start or restart the timer. | |
| result_t | stop (void) |
| Stop the timer. | |
Public Member Functions | |
| const char * | name (void) const |
| Get object name. | |
Static Public Member Functions | |
Operators | |
| static void * | operator new (std::size_t bytes) |
| Allocate space for a new object instance using the RTOS system allocator. | |
| static void * | operator new (std::size_t bytes, void *ptr) |
| Emplace a new object instance. | |
| static void * | operator new[] (std::size_t bytes) |
| Allocate space for an array of new object instances using the RTOS system allocator. | |
| static void * | operator new[] (std::size_t bytes, void *ptr) |
| Emplace an array of new object instances. | |
| static void | operator delete (void *ptr, std::size_t bytes) |
| Deallocate the dynamically allocated object instance. using the RTOS system allocator. | |
| static void | operator delete[] (void *ptr, std::size_t bytes) |
| Deallocate the dynamically allocated array of object. instances using the RTOS system allocator. | |
Static Public Attributes | |
| static const attributes | once_initializer |
| Default one shot timer initialiser. | |
| static const attributes_periodic | periodic_initializer |
| Default periodic timer initialiser. | |
User single-shot or periodic timer.
The CMISIS++ timer schedules the execution of a user function after a programmable interval. If the timer is periodic, the function is rescheduled automatically until the timer is stopped.
Definition at line 56 of file os-timer.h.
| os::rtos::timer::timer | ( | func_t | function, |
| func_args_t | args, | ||
| const attributes & | attr = once_initializer |
||
| ) |
Construct a timer object instance.
| [in] | function | Pointer to timer function. |
| [in] | args | Pointer to timer function arguments. |
| [in] | attr | Reference to attributes. |
This constructor shall initialise a timer object with attributes referenced by attr. If the attributes specified by attr are modified later, the timer attributes shall not be affected.
Upon successful initialisation, the state of the timer object shall become initialised.
Only the timer object itself may be used for running the function. It is not allowed to make copies of timer objects.
In cases where default condition variable attributes are appropriate, the variables timer::once_initializer
or timer::periodic_initializer
can be used to initialise timers. The effect shall be equivalent to creating a timer object with the simple constructor.
If the attr attributes are modified after the timer creation, the timer attributes shall not be affected.
Definition at line 139 of file os-timer.cpp.
| os::rtos::timer::timer | ( | const char * | name, |
| func_t | function, | ||
| func_args_t | args, | ||
| const attributes & | attr = once_initializer |
||
| ) |
Construct a named timer object instance.
| [in] | name | Pointer to name. |
| [in] | function | Pointer to timer function. |
| [in] | args | Pointer to timer function arguments. |
| [in] | attr | Reference to attributes. |
This constructor shall initialise a named timer object with attributes referenced by attr. If the attributes specified by attr are modified later, the timer attributes shall not be affected.
Upon successful initialisation, the state of the timer object shall become initialised.
Only the timer object itself may be used for running the function. It is not allowed to make copies of timer objects.
In cases where default condition variable attributes are appropriate, the variables timer::once_initializer
or timer::periodic_initializer
can be used to initialise timers. The effect shall be equivalent to creating a timer object with the simple constructor.
If the attr attributes are modified after the timer creation, the timer attributes shall not be affected.
Definition at line 171 of file os-timer.cpp.
| os::rtos::timer::~timer | ( | ) |
Destruct the timer object instance.
This destructor shall destroy the timer object; the object becomes, in effect, uninitialised. An implementation may cause the destructor to set the object to an invalid value.
If the timer is running, it must be automatically stopped.
Definition at line 215 of file os-timer.cpp.
|
inlineinherited |
Get object name.
All objects return a non-null string; anonymous objects return "-"
.
Definition at line 759 of file os-decls.h.
|
inlinestaticinherited |
Deallocate the dynamically allocated object instance. using the RTOS system allocator.
| ptr | Pointer to object. |
| bytes | Number of bytes to deallocate. |
The deallocation function (<IP_ADDRESS>) called by a delete-expression to render the value of ptr invalid.
ptr shall be a null pointer or its value shall be a value returned by an earlier call to the (possibly replaced) operator new() which has not been invalidated by an intervening call to operator delete(void*).
If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the earlier call to operator new.
The storage is deallocated using the RTOS system allocator.
Definition at line 122 of file os-inlines.h.
|
inlinestaticinherited |
Deallocate the dynamically allocated array of object. instances using the RTOS system allocator.
| ptr | Pointer to array of objects. |
| bytes | Number of bytes to deallocate. |
The deallocation function (<IP_ADDRESS>) called by the array form of a delete-expression to render the value of ptr invalid.
If ptr is null, does nothing. Otherwise, reclaims the storage allocated by the earlier call to operator new.
The storage is deallocated using the RTOS system allocator.
Definition at line 143 of file os-inlines.h.
|
inlinestaticinherited |
Allocate space for a new object instance using the RTOS system allocator.
| bytes | Number of bytes to allocate. |
The allocation function (<IP_ADDRESS>) called by a new-expression (5.3.4) to allocate a storage of size bytes suitably aligned to represent any object of that size. Return a non-null pointer to suitably aligned storage (3.7.4).
The storage is allocated using the RTOS system allocator.
Definition at line 44 of file os-inlines.h.
|
inlinestaticinherited |
Emplace a new object instance.
| bytes | Number of bytes to emplace. |
| ptr | Pointer to location to emplace the object. |
The allocation function (<IP_ADDRESS>) called by a placement new-expression to allocate a storage of size bytes suitably aligned to represent any object of that size. Return a non-null pointer to suitably aligned storage (3.7.4).
The storage is allocated using the RTOS system allocator.
Definition at line 81 of file os-inlines.h.
|
inlinestaticinherited |
Allocate space for an array of new object instances using the RTOS system allocator.
| bytes | Number of bytes to allocate. |
The allocation function (<IP_ADDRESS>) called by the array form of a new-expression (5.3.4) to allocate a storage of size bytes suitably aligned to represent any array object of that size or smaller.
The storage is allocated using the RTOS system allocator.
Definition at line 62 of file os-inlines.h.
|
inlinestaticinherited |
Emplace an array of new object instances.
| bytes | Number of bytes to emplace. |
| ptr | Pointer to location to emplace the object. |
The allocation function (<IP_ADDRESS>) called by the array form of a placement new-expression to allocate a storage of size bytes suitably aligned to represent any array object of that size or smaller.
The storage is allocated using the RTOS system allocator.
Definition at line 98 of file os-inlines.h.
|
inline |
Compare timers.
| true | The given timer is the same as this timer. |
| false | The timers are different. |
Identical timers should have the same memory address.
Definition at line 488 of file os-timer.h.
| result_t os::rtos::timer::start | ( | clock::duration_t | period | ) |
Start or restart the timer.
| [in] | period | Timer period, in clock units (ticks or seconds). |
| result::ok | The timer has been started or restarted. |
| ENOTRECOVERABLE | Timer could not be started. |
| EPERM | Cannot be invoked from an Interrupt Service Routines. |
If the period is 0, it is automatically adjusted to 1.
Definition at line 249 of file os-timer.cpp.
| result_t os::rtos::timer::stop | ( | void | ) |
Stop the timer.
| result::ok | The timer has been stopped. |
| EPERM | Cannot be invoked from an Interrupt Service Routines. |
| EAGAIN | The timer is not yet started. |
| ENOTRECOVERABLE | Timer could not be stopped. |
Remove the timer from the clock schedule list, so that the next execution of the function is cancelled.
A stopped timer can be restarted later with start()`.
Definition at line 313 of file os-timer.cpp.
|
static |
Default one shot timer initialiser.
This variable can be used to create a single run timer.
Definition at line 208 of file os-timer.h.


1 write to EnabledExperimentalFeatureNames
System.Management.Automation (1)
engine\ExperimentalFeature\ExperimentalFeature.cs (1)
151
EnabledExperimentalFeatureNames
= ProcessEnabledFeatures(enabledFeatures);
5 references to EnabledExperimentalFeatureNames
System.Management.Automation (5)
engine\ExperimentalFeature\ExperimentalFeature.cs (1)
279
return
EnabledExperimentalFeatureNames
.Contains(featureName);
engine\Modules\AnalysisCache.cs (3)
1097
if (ExperimentalFeature.
EnabledExperimentalFeatureNames
.Count > 0)
1109
string[] featureNames = new string[ExperimentalFeature.
EnabledExperimentalFeatureNames
.Count];
1110
foreach (string featureName in ExperimentalFeature.
EnabledExperimentalFeatureNames
)
engine\SessionState.cs (1)
376
ExperimentalFeature.
EnabledExperimentalFeatureNames
,


About
require 'parslet'
include Parslet
# Constructs a parser using a Parser Expression Grammar
parser = str('"') >>
(
str('\\').ignore >> any |
str('"').absent? >> any
).repeat.as(:string) >>
str('"')
result = parser.parse %Q("this is a valid \\"string\\"")
result # => {:string=>"this is a valid \"string\""@1}
A small Ruby library for constructing parsers in the PEG (Parsing Expression Grammar) fashion.
Parslet makes developing complex parsers easy. It does so by
- providing the best error reporting possible
- not generating reams of code for you to debug
Parslet takes the long way around to make your job easier. It allows for incremental language construction. Often, you start out small, implementing the atoms of your language first; parslet takes pride in making this possible.
Eager to try this out? Get started!


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Object org.apache.spark.mllib.evaluation.MultilabelMetrics
public class MultilabelMetrics
Evaluator for multilabel classification. param: predictionAndLabels an RDD of (predictions, labels) pairs, both are non-null Arrays, each with unique elements.
| Constructor Summary | |
|---|---|
MultilabelMetrics(RDD<scala.Tuple2<double[],double[]>> predictionAndLabels)
|
| Method Summary | |
|---|---|
double |
accuracy()
Returns accuracy |
double |
f1Measure()
Returns document-based f1-measure averaged by the number of documents |
double |
f1Measure(double label)
Returns f1-measure for a given label (category) |
double |
hammingLoss()
Returns Hamming-loss |
double[] |
labels()
Returns the sequence of labels in ascending order |
double |
microF1Measure()
Returns micro-averaged label-based f1-measure (equals to micro-averaged document-based f1-measure) |
double |
microPrecision()
Returns micro-averaged label-based precision (equals to micro-averaged document-based precision) |
double |
microRecall()
Returns micro-averaged label-based recall (equals to micro-averaged document-based recall) |
double |
precision()
Returns document-based precision averaged by the number of documents |
double |
precision(double label)
Returns precision for a given label (category) |
double |
recall()
Returns document-based recall averaged by the number of documents |
double |
recall(double label)
Returns recall for a given label (category) |
double |
subsetAccuracy()
Returns subset accuracy (for equal sets of labels) |
| Methods inherited from class Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public MultilabelMetrics(RDD<scala.Tuple2<double[],double[]>> predictionAndLabels)
| Method Detail |
|---|
public double subsetAccuracy()
public double accuracy()
public double hammingLoss()
public double precision()
public double recall()
public double f1Measure()
public double precision(double label)
label
- the label.
public double recall(double label)
label
- the label.
public double f1Measure(double label)
label
- the label.
public double microPrecision()
public double microRecall()
public double microF1Measure()
public double[] labels()
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Clever
Ground
Registration Successful!
Please download the cleverground app to start using the platform


The end of the sidewalk
Timer
Wave
FPS
Use the mouse to herd your little blobs away from the snatchers! Mind the edges... Chrome only :(
A game made in 48 hours by
Andrew Jackson


Responsive helper classes
Using responsive breakpoint classes for fine control of content visibility.
Responsive sites use breakpoints to adjust display based on user device. Here I use these breakpoints as the basis for a set of css-classes. These classes make it easier to explicitly control content based on break-points.
These helper classes allowing me to not only express
- content to hide on small displays, but also;
- content to hide on too large a display and
- content to show only for specific range of display widths
Describe Devices
Using Semantic-UI as a sample, I define a set of breakpoint widths
// -- mobile before here @mobileBreakpoint: 320px; //--- tablet in here --- @tabletBreakpoint: 768px; //--- laptop in here --- @desktopBreakpoint: 992px; //-- desktop in here -- @largeMonitorBreakpoint: 1200px; //-- wide screen in here -- @widescreenMonitorBreakpoint: 1920px; //-- tv after here.
Check which breakpoint
To help readability, define a device class that sits within these ranges. The indicator above shows the current device class.
As an example, here I've described a Laptop as
/**Simple style to show current break-point*/ .breakAt{} /**Break laptop as between tablet and computer*/ @media screen and (min-width:@tabletBreakpoint) and (max-width:@desktopBreakpoint) { /*laptop width*/ .breakAt::after{content:' Laptop'} }
Limit by smaller
Responsive is used to remove content when the display is limited (too small). so, lets add a style to hide content if display smaller than tablet.
@media screen and (min-width:@tabletBreakpoint) and (max-width:@desktopBreakpoint) { .breakAt::after{content:'Laptop'} /**too big*/ .tableOrSmaller, .mobileOrSmaller{display:'none'} }
This only shows if tablet or smaller.
Limit by bigger
In a similar way, we can hide if too big. Normally if width is bigger, I'm not interested in 'hiding' stuff, but I wanted styles that give me fine control. So, add a desktopOrBigger : show only if at desktop or bigger width.
@media screen and (min-device-width:@mobileBreakpoint) and (max-width:@tabletBreakpoint){ .breakAt::after{content:'Tablet'} /**too small*/ .desktopOrBigger {display:none} }
*This only shows on desktop or bigger
Limit in range
With this basic pattern, I define visibility for other section, such as desktop
@media screen and (min-width:@desktopBreakpoint) and (max-width:@largeMonitorBreakpoint) { /**desktop size*/ .breakAt::after{content:'desktop'} /**bigger*/ .widescreenOrBigger, .tvOrBigger {display: none;} /**smaller*/ .laptopOrSmaller, .tabletOrSmaller, .mobileOrSmaller {display:none;} }
Now I can limit by a 'range'.
So if i have content only for laptop I can express Laptop only using: laptopOrSmaller and laptopOrBigger

This only on laptop

This only for laptop
Putting it all together
I can now visualize which content will be shown with *Bigger or *Smaller class's
Bigger
Smaller
And toggle display based on current breakpoint
Desktop only
Laptop and desktop


U-Haul fined $71,000 after workers find asbestos during Kamloops building reno
by Karen EdwardsA moving equipment and storage rental company has been fined more than $71,000 after workers found asbestos-containing material in a Kamloops commercial building.
WorkSafeBC officials inspected a U-Haul Co. Canada Ltd. commercial building in Kamloops that was under renovation, according to a penalty report posted online last month.
At the time of the inspection, workers were removing drywall — a potential asbestos-containing material — from the wall and ceiling, the report said.
WorkSafeBC said no hazardous materials survey had been conducted and it issued a stop-work order. A survey conducted later confirmed the drywall compound as an asbestos-containing material.
The firm failed to ensure that a qualified person inspected the building to identify hazardous materials before workers began renovations work, WorkSafeBC said.
This was a high risk violation and the firm was fined $71,247.36 on Oct. 9.
WorkSafeBC said in an emailed statement it would not disclose the location of the building due to privacy reasons.


--- layout: post title: 'A Map for the Strata Conference: Who Goes to a Data Conference About Data?' date: '2012-02-28T16:12:23-08:00' tags: tumblr_url: http://alexhwilliams.tumblr.com/post/18463553381/a-map-for-the-strata-conference-who-goes-to-a-data ---


A collection of values, or "elements", that can be accessed sequentially.
The elements of the iterable are accessed by getting an Iterator
using the iterator getter, and using it to step through the values.
Stepping with the iterator is done by calling Iterator.moveNext,
and if the call returns true
,
the iterator has now moved to the next element,
which is then available as Iterator.current.
If the call returns false
, there are no more elements,
and iterator.current
returns null
.
You can create more than one iterator from the same Iterable
.
Each time iterator
is read, it returns a new iterator,
and different iterators can be stepped through independently,
each giving access to all the elements of the iterable.
The iterators of the same iterable should provide the same values
in the same order (unless the underlying collection is modified between
the iterations, which some collections allow).
You can also iterate over the elements of an Iterable
using the for-in loop construct, which uses the iterator
getter behind the
scenes.
For example, you can iterate over all of the keys of a Map,
because Map
keys are iterable.
Map kidsBooks = {'Matilda': 'Roald Dahl',
'Green Eggs and Ham': 'Dr Seuss',
'Where the Wild Things Are': 'Maurice Sendak'};
for (var book in kidsBooks.keys) {
print('$book was written by ${kidsBooks[book]}');
}
The List and Set classes are both Iterable
,
as are most classes in the dart:collection library.
Some Iterable collections can be modified.
Adding an element to a List
or Set
will change which elements it
contains, and adding a new key to a Map
changes the elements of Map.keys.
Iterators created after the change will provide the new elements, and may
or may not preserve the order of existing elements
(for example, a HashSet may completely change its order when a single
element is added).
Changing a collection while it is being iterated
is generally not allowed.
Doing so will break the iteration, which is typically signalled
by throwing a ConcurrentModificationError
the next time Iterator.moveNext is called.
The current value of Iterator.current getter
should not be affected by the change in the collection,
the current
value was set by the previous call to Iterator.moveNext.
Some iterables compute their elements dynamically every time they are
iterated, like the one returned by Iterable.generate
or the iterable
returned by a sync*
generator function. If the computation doesn't depend
on other objects that may change, then the generated sequence should be
the same one every time it's iterated.
The members of Iterable
, other than iterator
itself,
work by looking at the elements of the iterable.
This can be implemented by running through the iterator, but some classes
may have more efficient ways of finding the result
(like last or length on a List, or contains on a Set).
The methods that return another Iterable
(like map and where)
are all lazy - they will iterate the original (as necessary)
every time the returned iterable is iterated, and not before.
Since an iterable may be iterated more than once, it's not recommended to
have detectable side-effects in the iterator.
For methods like map and while
, the returned iterable will execute the
argument function on every iteration, so those functions should also not
have side effects.
- Implemented by
Constructors
- Iterable()
-
const
- Iterable.empty()
-
Creates an empty iterable.
constfactory - Iterable.generate(int count, [ E generator(int index) ])
-
Creates an
Iterable
which generates its elements dynamically.factory
Properties
- first → E
-
Returns the first element.
read-only - hashCode → int
-
Get a hash code for this object.
read-only, inherited - isEmpty → bool
-
Returns
true
if there are no elements in this collection.read-only - isNotEmpty → bool
-
Returns true if there is at least one element in this collection.
read-only - iterator → Iterator<E>
-
Returns a new
Iterator
that allows iterating the elements of thisIterable
.read-only - last → E
-
Returns the last element.
read-only - length → int
-
Returns the number of elements in
this
.read-only - runtimeType → Type
-
A representation of the runtime type of the object.
read-only, inherited - single → E
-
Checks that this iterable has only one element, and returns that element.
read-only
Operators
-
operator ==(
other) → bool -
The equality operator.
inherited
Methods
-
any(
bool f(E element)) → bool -
Checks whether any element of this iterable satisfies
test
. -
contains(
Object element) → bool -
Returns true if the collection contains an element equal to
element
. -
elementAt(
int index) → E -
Returns the
index
th element. -
every(
bool f(E element)) → bool -
Checks whether every element of this iterable satisfies
test
. -
expand(
Iterable f(E element)) → Iterable -
Expands each element of this Iterable into zero or more elements.
-
firstWhere(
bool test(E element), { E orElse() }) → E -
Returns the first element that satisfies the given predicate
test
. -
fold(
initialValue, dynamic combine(previousValue, E element)) → dynamic -
Reduces a collection to a single value by iteratively combining each element of the collection with an existing value
-
forEach(
void f(E element)) → void -
Applies the function
f
to each element of this collection in iteration order. -
join(
[String separator = "" ]) → String -
Converts each element to a String and concatenates the strings.
-
lastWhere(
bool test(E element), { E orElse() }) → E -
Returns the last element that satisfies the given predicate
test
. -
map(
dynamic f(E e)) → Iterable -
Returns a new lazy Iterable with elements that are created by calling
f
on each element of thisIterable
in iteration order. -
noSuchMethod(
Invocation invocation) → dynamic -
Invoked when a non-existent method or property is accessed.
inherited -
reduce(
E combine(E value, E element)) → E -
Reduces a collection to a single value by iteratively combining elements of the collection using the provided function.
-
singleWhere(
bool test(E element)) → E -
Returns the single element that satisfies
test
. -
skip(
int count) → Iterable<E> -
Returns an Iterable that provides all but the first
count
elements. -
skipWhile(
bool test(E value)) → Iterable<E> -
Returns an
Iterable
that skips leading elements whiletest
is satisfied. -
take(
int count) → Iterable<E> -
Returns a lazy iterable of the
count
first elements of this iterable. -
takeWhile(
bool test(E value)) → Iterable<E> -
Returns a lazy iterable of the leading elements satisfying
test
. -
toList(
{bool growable: true }) → List<E> -
toSet(
) → Set<E> -
Creates a Set containing the same elements as this iterable.
-
toString(
) → String -
Returns a string representation of (some of) the elements of
this
. -
where(
bool test(E element)) → Iterable<E> -
Returns a new lazy Iterable with all elements that satisfy the predicate
test
.


Angular Tutorial Videos
Thu Sep 10, 2015
Here is my collection of free tutorial videos. Could be really helpful for people new to Angular.
1. Shaping up with Angular JS
Gregg Pollack’s “Shaping up with Angular.js” from codeschool.com has been there for a while. It is one of the tutorials that have the best intro. The series covers Angular setup, binding, controllers, directives, filters, form handling, and services. The best part is its challenges after each chapter.
The tutorial might be a bit confusing to navigate. Make sure you scroll all the way to the top, and click the “START COURSE” button, which will list all the chapters. It’s recommended starting from the beginning in the order. The tutorial walks you through building a gem store project. Skipping the previous chapters might make yourself lost.
At the bottom right corner, you will find the “START CHALLENGES” button which brings you to the exercises. The challenge mode gives you an inline editor to play around the code. Your editing will be immediately reflected in the “Preview” panel. Pretty handy for learn by play.
The tutorial has a sequel – “Staying Sharp with Angular.js”. Alyssa Nicoll will be your mentor. The first chapter covers router. It is free. The following chapters might need payment to unlock.
Free tutorial: Shaping up with Angular.js
Sequel: Staying Sharp with Angular.js
2. Egghead IO - New to Angular JS?
Egghead is famous of its bite-sized videos. Each video can be consumed within 10 min. The entire tutorial is very easy to navigate. The noteworthy is that each short clip has its own discussion section. You might very well learn something new from these informative discussions.
This tutorial spent a lot of inks on directives and isolated scopes, which are essential to writing better components in Angular JS.
Egghead.io is a powerhouse for all Angular learning. If you’d like to adventure to specific topics or advanced usage, check out this list of all Angular lessons.
Egghead.io: New to AngularJS?
3. Angular Youtube Channel
For people who prefer picking their own lessons, Angular’s Youtube channel is the gold mine.
Strictly speaking, the channel itself is not a tutorial site, however, here, you will find great videos covering wide range of topics. I will give you some examples:
- Julie Ralph’s video on Angular Protractor test and more.
- Vojta Jina’s Testing Directives
- Reusable Components in Angular: Design patterns, transclusion, and more
Youtube Angular channel
Other Youtube channels related to Angular JS:
4. Others
- PluralSight.com Angular courses
- John Papa - 10 AngularJS Patterns
- David Mosher’s Advanced Directives
- Now, some silly stuff ng-wat inspired by JS Wat


(#) Vector Image Generation !!! WARNING: Vector Image Generation This is a warning. Id : `VectorRaster` Summary : Vector Image Generation Severity : Warning Category : Correctness Platform : Android Vendor : Android Open Source Project Feedback : https://issuetracker.google.com/issues/new?component=192708 Affects : Resource files Editing : This check runs on the fly in the IDE editor Implementation : [Source Code](https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-checks/src/main/java/com/android/tools/lint/checks/VectorDetector.java) Tests : [Source Code](https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-tests/src/test/java/com/android/tools/lint/checks/VectorDetectorTest.java) Copyright Year : 2015 Vector icons require API 21 or API 24 depending on used features, but when `minSdkVersion` is less than 21 or 24 and Android Gradle plugin 1.4 or higher is used, a vector drawable placed in the `drawable` folder is automatically moved to `drawable-anydpi-v21` or `drawable-anydpi-v24` and bitmap images are generated for different screen resolutions for backwards compatibility. However, there are some limitations to this raster image generation, and this lint check flags elements and attributes that are not fully supported. You should manually check whether the generated output is acceptable for those older devices. (##) Example Here is an example of lint warnings produced by this check: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~text src/main/res/drawable/foo.xml:6:Warning: This attribute is not supported in images generated from this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:autoMirrored="true" -------------------- src/main/res/drawable/foo.xml:7:Warning: Resource references will not work correctly in images generated for this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:tint="?attr/colorControlActivated"> --------------------------- src/main/res/drawable/foo.xml:9:Warning: This tag is not supported in images generated from this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] <clip-path android:pathData="M10,10h40v30h-40z"/> ------------------------------------------------- src/main/res/drawable/foo.xml:19:Warning: Resource references will not work correctly in images generated for this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:strokeColor="@color/white" ------------ src/main/res/drawable/foo.xml:23:Warning: This attribute is not supported in images generated from this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:trimPathEnd="0" ------------------- src/main/res/drawable/foo.xml:24:Warning: This attribute is not supported in images generated from this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:trimPathOffset="0" ---------------------- src/main/res/drawable/foo.xml:25:Warning: This attribute is not supported in images generated from this vector icon for API < 21; check generated icon to make sure it looks acceptable [VectorRaster] android:trimPathStart="0" /> --------------------- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Here is the source file referenced above: `src/main/res/drawable/foo.xml`: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~xml linenumbers <vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="76dp" android:width="76dp" android:viewportHeight="48" android:viewportWidth="48" android:autoMirrored="true" android:tint="?attr/colorControlActivated"> <clip-path android:pathData="M10,10h40v30h-40z"/> <group android:name="root" android:translateX="24.0" android:translateY="24.0" > <path android:name="progressBar" android:fillColor="#00000000" android:pathData="M0, 0 m 0, -19 a 19,19 0 1,1 0,38 a 19,19 0 1,1 0,-38" android:strokeColor="@color/white" android:strokeLineCap="square" android:strokeLineJoin="miter" android:strokeWidth="4" android:trimPathEnd="0" android:trimPathOffset="0" android:trimPathStart="0" /> </group> </vector> ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can also visit the [source code](https://cs.android.com/android-studio/platform/tools/base/+/mirror-goog-studio-main:lint/libs/lint-tests/src/test/java/com/android/tools/lint/checks/VectorDetectorTest.java) for the unit tests for this check to see additional scenarios. The above example was automatically extracted from the first unit test found for this lint check, `VectorDetector.testWarn`. To report a problem with this extracted sample, visit https://issuetracker.google.com/issues/new?component=192708. (##) Suppressing You can suppress false positives using one of the following mechanisms: * Adding the suppression attribute `tools:ignore="VectorRaster"` on the problematic XML element (or one of its enclosing elements). You may also need to add the following namespace declaration on the root element in the XML file if it's not already there: `xmlns:tools="http://schemas.android.com/tools"`. * Using a special `lint.xml` file in the source tree which turns off the check in that folder and any sub folder. A simple file might look like this: ```xml <?xml version="1.0" encoding="UTF-8"?> <lint> <issue id="VectorRaster" severity="ignore" /> </lint> ``` Instead of `ignore` you can also change the severity here, for example from `error` to `warning`. You can find additional documentation on how to filter issues by path, regular expression and so on [here](https://googlesamples.github.io/android-custom-lint-rules/usage/lintxml.md.html). * In Gradle projects, using the DSL syntax to configure lint. For example, you can use something like ```gradle lintOptions { disable 'VectorRaster' } ``` In Android projects this should be nested inside an `android { }` block. * For manual invocations of `lint`, using the `--ignore` flag: ``` $ lint --ignore VectorRaster ...` ``` * Last, but not least, using baselines, as discussed [here](https://googlesamples.github.io/android-custom-lint-rules/usage/baselines.md.html).


Static Public Member Functions | |
| static void | Changes< T > (this IListCellRead< T > source, Action< IEnumerable< ListCellChanged< T >>> handler) |
| Listen for changes to a list cell until the scope ends. Whenever the list is modified, a sequential handler will be invoked. The handler is passed a list of all changes that have happened. The handler is also invoked once with an 'add' change, containing the current list elements. More... | |
| static IListCellRead< TOut > | WithEach< TIn, TOut > (this IListCellRead< TIn > source, Func< TIn, ICellRead< TOut >> selector) |
| Creates a new temporal scope for each element in a list cell. If new elements are added to the list, new scopes are initialized. Likewise, when an element is removed from the list its scope ends. All element scopes end when the calling temporal scope ends. This behaviour is also combined with map-like behavior, where a function is applied to each element in the list, and the resulting list is this method's return value. More... | |
| static void | Bind< T > (this IListCellRead< T > source, System.Collections.IList destination) |
| Bind the contents of a list to be equal to the contents of a list cell, until the scope ends. More... | |
| static void | Bind< T > (this IListCellRead< T > source, IListCellWrite< T > destination) |
| Bind the contents of a list cell to be equal to the contents of another list cell, until the scope ends. More... | |
| static IListCellRead< TOut > | Select< TIn, TOut > (this IListCellRead< TIn > source, Func< TIn, TOut > transform) |
| Projects each element of a list cell by applying a transformation function. More... | |
| static ICellRead< T > | FirstOrDefault< T > (this IListCellRead< T > list) |
| Returns a read-only memory cell which is always equal to the first element of a list. More... | |
| static ICellRead< T > | ElementAt< T > (this IListCellRead< T > list, ICellRead< int > index) |
| Returns an observable value containing the element of an observable list at a specified observable index. More... | |
| static ICellRead< TResult > | Aggregate< T, TResult > (this IListCellRead< T > list, Func< IEnumerable< T >, TResult > aggregator) |
| static IListCellRead< T > | Flatten< T > (this IListCellRead< ICellRead< T >> list) |
| Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change. More... | |
| static IListCellRead< T > | Flatten< T > (this IListCellRead< MemoryCell< T >> list) |
| Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change. More... | |
| static IListCellRead< T > | Flatten< T, TCell > (this IListCellRead< TCell > list) |
| Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change. More... | |
|
inlinestatic |
Bind the contents of a list to be equal to the contents of a list cell, until the scope ends.
| T | The type of elements in the source list. |
| source | The list to be observed. |
| destination | The list to be constrained. |
|
inlinestatic |
Bind the contents of a list cell to be equal to the contents of another list cell, until the scope ends.
| T | The type of elements in the lists. |
| source | The list to be observed. |
| destination | The list to be constrained. |
|
inlinestatic |
Listen for changes to a list cell until the scope ends. Whenever the list is modified, a sequential handler will be invoked. The handler is passed a list of all changes that have happened. The handler is also invoked once with an 'add' change, containing the current list elements.
| T | The type of list elements. |
| source | The list to observe. |
| handler | The handler to invoke when the list changes. |
|
inlinestatic |
Returns an observable value containing the element of an observable list at a specified observable index.
| T | The type of element in the list |
| list | The observable list. |
| index | The observable value containing the index into the list. |
|
inlinestatic |
Returns a read-only memory cell which is always equal to the first element of a list.
| T | The type of elements of list. |
| list | The source list. |
|
inlinestatic |
Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change.
| T | The type of the list elements. |
| list | The list of observable values. |
|
inlinestatic |
Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change.
| T | The type of the list elements. |
| list | The list of observable values. |
|
inlinestatic |
Flatten a list of observable values into a list. If an observable element changes value, the result list emits a 'replace' change.
| T | The type of the list elements. |
| list | The list of observable values. |
| TCell | : | ICellRead<T> |
|
inlinestatic |
Projects each element of a list cell by applying a transformation function.
| TIn | The type of the elements of the source list. |
| TOut | The type of value returned by transform. |
| source | The source list. |
| transform | A transform function to apply to each element. |
|
inlinestatic |
Creates a new temporal scope for each element in a list cell. If new elements are added to the list, new scopes are initialized. Likewise, when an element is removed from the list its scope ends. All element scopes end when the calling temporal scope ends. This behaviour is also combined with map-like behavior, where a function is applied to each element in the list, and the resulting list is this method's return value.
| TIn | The type of items in the source list. |
| TOut | The type of items in the result list. |
| source | The source list. |
| selector | The function to initialize each element scope. |


{% extends "views/base.html" %} {% block breadcrumb %}
This page lists the content of {{ directory }} that contains all the mailing lists managed by mlmmj.


{% extends "layout.html" %} {% block title %}Home{% endblock %} {% block head %} {{ super() }} {% endblock %} {% block content %}
ReSim (chemoREsistance SIMulator) simulates cancer chemoresistance dynamics. It is based on a stochastic model describing the interaction between chemotheraputics and various cancer cell subpopulations (including sensitive, primary resistant, aquired resistant and quiescent cancer cells).
Web application (powered by Flask) provides a simplified version, and a convenient way to visualize result. Use CUI if you need more control in input params. Both versions are written in Python2.7.


{% if any_generator_not_running %}
The statistics on this page use data sources that are too big to show all at once. Use the page navigation buttons below to select which parts of the data to view. These controls affect all statistics on this page.
{% for rest_source in rest_sources|sort(attribute='title') %}{{ rest_source.title }} {% if rest_source.chunk_size > 0%} Page: 0 Items per page: {% else %} {% endif %}
{% endfor %}


001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.io; 018 019 import java.io.File; 020 import java.lang.ref.PhantomReference; 021 import java.lang.ref.ReferenceQueue; 022 import java.util.ArrayList; 023 import java.util.Collection; 024 import java.util.Collections; 025 import java.util.HashSet; 026 import java.util.List; 027 028 /** 029 * Keeps track of files awaiting deletion, and deletes them when an associated 030 * marker object is reclaimed by the garbage collector. 031 *
 032 * This utility creates a background thread to handle file deletion. 033 * Each file to be deleted is registered with a handler object. 034 * When the handler object is garbage collected, the file is deleted. 035 *
 036 * In an environment with multiple class loaders (a servlet container, for 037 * example), you should consider stopping the background thread if it is no 038 * longer needed. This is done by invoking the method 039 * {@link #exitWhenFinished}, typically in 040 * {@link javax.servlet.ServletContextListener#contextDestroyed} or similar. 041 * 042 * @author Noel Bergman 043 * @author Martin Cooper 044 * @version $Id: FileCleaningTracker.java 1005707 2010-10-08 04:02:57Z niallp $ 045 */ 046 public class FileCleaningTracker { 047 /** 048 * Queue of Tracker instances being watched. 049 */ 050 ReferenceQueue<Object> q = new ReferenceQueue<Object>(); 051 /** 052 * Collection of Tracker instances in existence. 053 */ 054 final Collection<Tracker> trackers = Collections.synchronizedSet(new HashSet<Tracker>()); // synchronized 055 /** 056 * Collection of File paths that failed to delete. 057 */ 058 final List<String> deleteFailures = Collections.synchronizedList(new ArrayList<String>()); 059 /** 060 * Whether to terminate the thread when the tracking is complete. 061 */ 062 volatile boolean exitWhenFinished = false; 063 /** 064 * The thread that will clean up registered files. 065 */ 066 Thread reaper; 067 068 //----------------------------------------------------------------------- 069 /** 070 * Track the specified file, using the provided marker, deleting the file 071 * when the marker instance is garbage collected. 072 * The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used. 073 * 074 * @param file the file to be tracked, not null 075 * @param marker the marker object used to track the file, not null 076 * @throws NullPointerException if the file is null 077 */ 078 public void track(File file, Object marker) { 079 track(file, marker, (FileDeleteStrategy) null); 080 } 081 082 /** 083 * Track the specified file, using the provided marker, deleting the file 084 * when the marker instance is garbage collected. 085 * The speified deletion strategy is used. 086 * 087 * @param file the file to be tracked, not null 088 * @param marker the marker object used to track the file, not null 089 * @param deleteStrategy the strategy to delete the file, null means normal 090 * @throws NullPointerException if the file is null 091 */ 092 public void track(File file, Object marker, FileDeleteStrategy deleteStrategy) { 093 if (file == null) { 094 throw new NullPointerException("The file must not be null"); 095 } 096 addTracker(file.getPath(), marker, deleteStrategy); 097 } 098 099 /** 100 * Track the specified file, using the provided marker, deleting the file 101 * when the marker instance is garbage collected. 102 * The {@link FileDeleteStrategy#NORMAL normal} deletion strategy will be used. 103 * 104 * @param path the full path to the file to be tracked, not null 105 * @param marker the marker object used to track the file, not null 106 * @throws NullPointerException if the path is null 107 */ 108 public void track(String path, Object marker) { 109 track(path, marker, (FileDeleteStrategy) null); 110 } 111 112 /** 113 * Track the specified file, using the provided marker, deleting the file 114 * when the marker instance is garbage collected. 115 * The speified deletion strategy is used. 116 * 117 * @param path the full path to the file to be tracked, not null 118 * @param marker the marker object used to track the file, not null 119 * @param deleteStrategy the strategy to delete the file, null means normal 120 * @throws NullPointerException if the path is null 121 */ 122 public void track(String path, Object marker, FileDeleteStrategy deleteStrategy) { 123 if (path == null) { 124 throw new NullPointerException("The path must not be null"); 125 } 126 addTracker(path, marker, deleteStrategy); 127 } 128 129 /** 130 * Adds a tracker to the list of trackers. 131 * 132 * @param path the full path to the file to be tracked, not null 133 * @param marker the marker object used to track the file, not null 134 * @param deleteStrategy the strategy to delete the file, null means normal 135 */ 136 private synchronized void addTracker(String path, Object marker, FileDeleteStrategy deleteStrategy) { 137 // synchronized block protects reaper 138 if (exitWhenFinished) { 139 throw new IllegalStateException("No new trackers can be added once exitWhenFinished() is called"); 140 } 141 if (reaper == null) { 142 reaper = new Reaper(); 143 reaper.start(); 144 } 145 trackers.add(new Tracker(path, deleteStrategy, marker, q)); 146 } 147 148 //----------------------------------------------------------------------- 149 /** 150 * Retrieve the number of files currently being tracked, and therefore 151 * awaiting deletion. 152 * 153 * @return the number of files being tracked 154 */ 155 public int getTrackCount() { 156 return trackers.size(); 157 } 158 159 /** 160 * Return the file paths that failed to delete. 161 * 162 * @return the file paths that failed to delete 163 * @since Commons IO 2.0 164 */ 165 public List<String> getDeleteFailures() { 166 return deleteFailures; 167 } 168 169 /** 170 * Call this method to cause the file cleaner thread to terminate when 171 * there are no more objects being tracked for deletion. 172 *
 173 * In a simple environment, you don't need this method as the file cleaner 174 * thread will simply exit when the JVM exits. In a more complex environment, 175 * with multiple class loaders (such as an application server), you should be 176 * aware that the file cleaner thread will continue running even if the class 177 * loader it was started from terminates. This can consitute a memory leak. 178 *
 179 * For example, suppose that you have developed a web application, which 180 * contains the commons-io jar file in your WEB-INF/lib directory. In other 181 * words, the FileCleaner class is loaded through the class loader of your 182 * web application. If the web application is terminated, but the servlet 183 * container is still running, then the file cleaner thread will still exist, 184 * posing a memory leak. 185 *
 186 * This method allows the thread to be terminated. Simply call this method 187 * in the resource cleanup code, such as {@link javax.servlet.ServletContextListener#contextDestroyed}. 188 * Once called, no new objects can be tracked by the file cleaner. 189 */ 190 public synchronized void exitWhenFinished() { 191 // synchronized block protects reaper 192 exitWhenFinished = true; 193 if (reaper != null) { 194 synchronized (reaper) { 195 reaper.interrupt(); 196 } 197 } 198 } 199 200 //----------------------------------------------------------------------- 201 /** 202 * The reaper thread. 203 */ 204 private final class Reaper extends Thread { 205 /** Construct a new Reaper */ 206 Reaper() { 207 super("File Reaper"); 208 setPriority(Thread.MAX_PRIORITY); 209 setDaemon(true); 210 } 211 212 /** 213 * Run the reaper thread that will delete files as their associated 214 * marker objects are reclaimed by the garbage collector. 215 */ 216 @Override 217 public void run() { 218 // thread exits when exitWhenFinished is true and there are no more tracked objects 219 while (exitWhenFinished == false || trackers.size() > 0) { 220 try { 221 // Wait for a tracker to remove. 222 Tracker tracker = (Tracker) q.remove(); // cannot return null 223 trackers.remove(tracker); 224 if (!tracker.delete()) { 225 deleteFailures.add(tracker.getPath()); 226 } 227 tracker.clear(); 228 } catch (InterruptedException e) { 229 continue; 230 } 231 } 232 } 233 } 234 235 //----------------------------------------------------------------------- 236 /** 237 * Inner class which acts as the reference for a file pending deletion. 238 */ 239 private static final class Tracker extends PhantomReference<Object> { 240 241 /** 242 * The full path to the file being tracked. 243 */ 244 private final String path; 245 /** 246 * The strategy for deleting files. 247 */ 248 private final FileDeleteStrategy deleteStrategy; 249 250 /** 251 * Constructs an instance of this class from the supplied parameters. 252 * 253 * @param path the full path to the file to be tracked, not null 254 * @param deleteStrategy the strategy to delete the file, null means normal 255 * @param marker the marker object used to track the file, not null 256 * @param queue the queue on to which the tracker will be pushed, not null 257 */ 258 Tracker(String path, FileDeleteStrategy deleteStrategy, Object marker, ReferenceQueue<? super Object> queue) { 259 super(marker, queue); 260 this.path = path; 261 this.deleteStrategy = (deleteStrategy == null ? FileDeleteStrategy.NORMAL : deleteStrategy); 262 } 263 264 /** 265 * Return the path. 266 * 267 * @return the path 268 */ 269 public String getPath() { 270 return path; 271 } 272 273 /** 274 * Deletes the file associated with this tracker instance. 275 * 276 * @return true if the file was deleted successfully; 277 * false otherwise. 278 */ 279 public boolean delete() { 280 return deleteStrategy.deleteQuietly(new File(path)); 281 } 282 } 283 284 }