{% import "./_schedule-date.tpl" as scheduleDate with context %} {% import "./_schedule-show.tpl" as scheduleShow with context %}
BBC World Service is the leading international broadcaster, and includes a network of correspondents providing impartial news, reports and analysis in 33 languages from locations around the world. It offers a wide variety of information programming, including programs on arts, sports, science and business.
{% endset %} {{ scheduleShow.render( time='12:00 AM/CT', title='BBC World Service', hasAudio=true, description=showDescription ) }} {% set showDescription %}Up-to-the-minute news, analysis, commentary and coverage of politics, arts, sports and more—from around the world and in and around Chicago.
Morning Edition is hosted by WBEZ's Lisa Labuz and NPR's David Greene, Steve Inskeep, Noel King, and Rachel Martin.
{% endset %} {{ scheduleShow.render( time='5:00 AM/CT', title='Morning Edition: Hour 1', hasAudio=true, description=showDescription ) }} {{ scheduleShow.render( time='6:00 AM/CT', title='Morning Edition: Hour 2', isLive=true, hasAudio=true, description=showDescription, isOpen=true ) }} {{ scheduleShow.render( time='7:00 AM/CT', title='Morning Edition: Hour 3', description=showDescription ) }} {{ scheduleShow.render( time='8:00 AM/CT', title='Morning Edition: Hour 4', description=showDescription ) }} {% set showDescription %}A dynamic mix of news and culture in Chicago. Hosted by Jenn White. From WBEZ.
Call-in (live):<PHONE_NUMBER>
{% endset %} {{ scheduleShow.render( time='9:00 AM/CT', title='Morning Shift', description=showDescription ) }} {% set showDescription %}Every day, host Joshua Johnson convenes a conversation about the most important issues of our time. The show takes a deep and unflinching look at America, bringing context and insight to stories unfolding across the country and the world.
1A is hosted by Joshua Johnson.
{% endset %} {{ scheduleShow.render( time='10:00 AM/CT', title='1A', description=showDescription ) }} {% set showDescription %}In-depth interviews with prominent cultural and entertainment figures, as well as distinguished experts on current affairs and news. From WHYY and NPR.
Fresh Air is hosted by Terry Gross.
{% endset %} {{ scheduleShow.render( time='11:00 AM/CT', title='Fresh Air', description=showDescription ) }} {% set showDescription %}From Nobel Peace Prize winners to Nicaraguan sweatshop workers, we highlight a range of voices that go beyond the headlines. From WBEZ.
Worldview is hosted by Jerome McDonnell.
{% endset %} {{ scheduleShow.render( time='12:00 PM/CT', title='Worldview', description=showDescription ) }} {% set showDescription %}A timely, smart reflection of the fluid world of news as it’s happening. The show’s daily lineup includes interviews with NPR reporters, editors and bloggers, as well as leading newsmakers, innovators and artists from across the U.S. and around the globe. From WBUR and NPR.
Here & Now
is co-hosted by Robin Young and Jeremy Hobson.
A mix of news, interviews, commentaries, reviews, and offbeat features from Chicago and around the world. From WBEZ and NPR.
All Things Considered is hosted by WBEZ's Melba Lara and NPR's Ailsa Chang, Audie Cornish, Mary Louise Kelly, and Ari Shapiro. Michel Martin hosts on the weekends.
{% endset %} {{ scheduleShow.render( time='3:00 PM/CT', title='All Things Considered: Hour 1', description=showDescription ) }} {{ scheduleShow.render( time='4:00 PM/CT', title='All Things Considered: Hour 2', description=showDescription ) }} {% set showDescription %}A daily take on business and economics news for the rest of us. From American Public Media.
Marketplace is hosted by Kai Ryssdal.
A mix of news, interviews, commentaries, reviews, and offbeat features from Chicago and around the world. From WBEZ and NPR.
All Things Considered is hosted by WBEZ's Melba Lara and NPR's Ailsa Chang, Audie Cornish, Mary Louise Kelly, and Ari Shapiro. Michel Martin hosts on the weekends.
{% endset %} {{ scheduleShow.render( time='5:00 PM/CT', title='All Things Considered: Hour 3', description=showDescription ) }} {{ scheduleShow.render( time='6:00 PM/CT', title='All Things Considered: Hour 4', description=showDescription ) }} {% set showDescription %}A daily take on business and economics news for the rest of us. From American Public Media.
Marketplace is hosted by Kai Ryssdal.
The acclaimed podcast from The New York Times, hosted by Michael Barbaro and powered by The New York Times’ journalism. Each evening, Michael and his colleagues take you
behind the scenes to understand the deeper forces driving many of
the biggest stories.
In-depth interviews with prominent cultural and entertainment figures, as well as distinguished experts on current affairs and news. From WHYY and NPR.
Fresh Air is hosted by Terry Gross.
{% endset %} {{ scheduleShow.render( time='8:00 PM/CT', title='Fresh Air', description=showDescription ) }} {% set showDescription %}True stories, told live and without notes, to standing-room-only crowds worldwide. Moth storytellers stand alone, under a spotlight, with only a microphone and a roomful of strangers.
Hear more from The Moth.
{% endset %} {{ scheduleShow.render( time='9:00 PM/CT', title='The Moth', description=showDescription ) }} {% set showDescription %}Every day, host Joshua Johnson convenes a conversation about the most important issues of our time. The show takes a deep and unflinching look at America, bringing context and insight to stories unfolding across the country and the world.
1A is hosted by Joshua Johnson.
{% endset %} {{ scheduleShow.render( time='10:00 PM/CT', title='1A', description=showDescription ) }} {% set showDescription %}BBC World Service is the leading international broadcaster, and includes a network of correspondents providing impartial news, reports and analysis in 33 languages from locations around the world. It offers a wide variety of information programming, including programs on arts, sports, science and business.
{% endset %} {{ scheduleShow.render( time='11:00 PM/CT', title='BBC World Service', description=showDescription ) }}


You can add your own language. Limitation: character | is not
allowed. This example is bavarian from
http://www.bayrisch-lernen.de/popups/uhrzeit.html
and http://himbeerwerft.de/2013/10/bayrische-uhrzeiten/
(To every real bavarian: excuse me, if the translation ist to bad :-))
First we need exactly 24 hours:
Now we need the text for each 5 minutes of an hour, $1 means the current hour, $2 will be replaced with the next hour. We need exactly 12 entries.
A * before a word leads to a bold face font (see example)


--- layout: help ---
The test properties dialog is displayed using either the View | Properties menu item on the main menu or the Properties item on the context menu. It shows information about the test and - if it has been run - about the results. The dialog contains a "pin" button in the upper right corner, which causes it to remain open as the user clicks on different tests.


{% extends "admin/base_site.html" %} {% block content %}
To apply our moderated selections of players to the whitelist, please press the "apply whitelist" button below.
{{ error }}


Prepare client portfolio to generate interest of prospective investors.
Review client specific documents such as non-disclosure agreements, marketing materials, and financial statements.
Review portfolio on a periodically to ensure all current information is on file.
Participate in team efforts to achieve departmental and company goals.
Comply with all policies, practices, and procedures and report all unsafe activities to firm partners
Perform other duties as assigned
Ability to read, analyze and interpret general business periodicals, professional journals, technical procedures, or governmental regulations. Ability to write reports, business correspondence, and procedure manuals. Ability to effectively present information and respond to questions from groups of managers, clients, customers and the general public.
Ability to define problems, collect data, establish facts, and draw valid conclusions.
Ability to calculate figures and amounts such as discounts, interest, commissions, proportions, percentages, area, circumference and volume.
Proficient personal computer skills include electronic e-mail, recordkeeping, routine database activity, word processing, spreadsheet, etc.
Ability to handle multiple tasks simultaneously.
Ability to handle a rigorous schedule of deadlines.
Experienced in professional business writing preferred; including writing business plans and information memorandums.
Experience working with entrepreneurs is a plus.
Prioritization and organization skills.
Proficient in financial-modeling, financial-analysis, and Excel.
Commercial understanding and awareness of business and operations in various industries.
Possess valid and current driver license.
No personal history of enforcement actions by the Securities Exchange Commission, FINRA, or any state securities regulatory bodies.
Bachelor's degree or advanced degree in Finance, Marketing, or Accounting or an unrelated degree with significant work experience in one or more of these fields.
Availability for occasional travel and working outside of normal operating hours.


The State Minister for Social Affairs, Dr Alvera Mukabaramba, welcomed the findings, noting that they will help the Government in fighting corruption. She said e-services and protection of whistle-blowers are among the new mechanisms being used to fight graft.
The State Minister for Social Affairs, Dr Alvera Mukabaramba, welcomed the findings, noting that they will help the Government in fighting corruption. She said e-services and protection of whistle-blowers are among the new mechanisms being used to fight graft.
The State Minister for Social Affairs, Dr Alvera Mukabaramba, welcomed the findings, noting that they will help the Government in fighting corruption. She said e-services and protection of whistle-blowers are among the new mechanisms being used to fight graft.
The State Minister for Social Affairs, Dr Alvera Mukabaramba, welcomed the findings, noting that they will help the Government in fighting corruption. She said e-services and protection of whistle-blowers are among the new mechanisms being used to fight graft.


Gecode::Set::CachedView< View > Class Template Reference
[Set views]
Cached set view. More...
#include <view.hpp>
Public Member Functions | |
| template<class I > | |
| ModEvent | excludeI (Space &home, I &iter) |
| template<class I > | |
| ModEvent | includeI (Space &home, I &iter) |
| template<class I > | |
| ModEvent | intersectI (Space &home, I &iter) |
Protected Attributes | |
| LUBndSet | lubCache |
| The cached least upper bound. | |
| GLBndSet | glbCache |
| The cached greatest lower bound. | |
Constructors and initialization | |
|
| |
| CachedView (void) | |
| Default constructor. | |
| CachedView (const View &y) | |
| Initialize with set view y. | |
Value access | |
|
| |
| unsigned int | cardMin (void) const |
| Return minimum cardinality. | |
| unsigned int | cardMax (void) const |
| Return maximum cardinality. | |
| int | lubMin (void) const |
| Return minimum of the least upper bound. | |
| int | lubMax (void) const |
| Return maximum of the least upper bound. | |
| int | lubMinN (unsigned int n) const |
| Return n-th smallest element of the least upper bound. | |
| int | glbMin (void) const |
| Return minimum of the greatest lower bound. | |
| int | glbMax (void) const |
| Return maximum of the greatest lower bound. | |
| unsigned int | glbSize (void) const |
| Return the number of elements in the greatest lower bound. | |
| unsigned int | lubSize (void) const |
| Return the number of elements in the least upper bound. | |
| unsigned int | unknownSize (void) const |
| Return the number of unknown elements. | |
Domain tests | |
|
| |
| bool | contains (int i) const |
| Test whether i is in the greatest lower bound. | |
| bool | notContains (int i) const |
| Test whether i is not in the least upper bound. | |
Domain update by value | |
|
| |
| ModEvent | cardMin (Space &home, unsigned int m) |
| Restrict cardinality to be greater than or equal to m. | |
| ModEvent | cardMax (Space &home, unsigned int m) |
| Restrict cardinality to be less than or equal to m. | |
| ModEvent | include (Space &home, int i, int j) |
| Update greatest lower bound to include all elements between and including i and j. | |
| ModEvent | exclude (Space &home, int i, int j) |
| Restrict least upper bound to not contain all elements between and including i and j. | |
| ModEvent | include (Space &home, int i) |
| Update greatest lower bound to contain i. | |
| ModEvent | exclude (Space &home, int i) |
| Restrict least upper bound to not contain i. | |
| ModEvent | intersect (Space &home, int i, int j) |
| Update least upper bound to contain at most all elements between and including i and j. | |
| ModEvent | intersect (Space &home, int i) |
| Update least upper bound to contain at most the element i. | |
Domain update by range iterator | |
|
| |
| template<class I > | |
| ModEvent | excludeI (Space &home, I &i) |
| Remove range sequence described by i from least upper bound. | |
| template<class I > | |
| ModEvent | includeI (Space &home, I &i) |
| Include range sequence described by i in greatest lower bound. | |
| template<class I > | |
| ModEvent | intersectI (Space &home, I &iter) |
| Intersect least upper bound with range sequence described by i. | |
Dependencies | |
|
| |
| void | subscribe (Space &home, Propagator &p, PropCond pc, bool schedule=true) |
| Subscribe propagator p with propagation condition pc to view. | |
| void | cancel (Space &home, Propagator &p, PropCond pc) |
| Cancel subscription of propagator p with propagation condition pc to view. | |
| void | subscribe (Space &home, Advisor &a) |
| Subscribe advisor a to view. | |
| void | cancel (Space &home, Advisor &a) |
| Cancel subscription of advisor a. | |
Delta information for advisors | |
|
| |
| int | glbMin (const Delta &d) const |
| Return minimum value just pruned from glb. | |
| int | glbMax (const Delta &d) const |
| Return maximum value just pruned from glb. | |
| bool | glbAny (const Delta &d) const |
| Test whether arbitrary values got pruned from glb. | |
| int | lubMin (const Delta &d) const |
| Return minimum value just pruned from lub. | |
| int | lubMax (const Delta &d) const |
| Return maximum value just pruned from lub. | |
| bool | lubAny (const Delta &d) const |
| Test whether arbitrary values got pruned from lub. | |
| static ModEvent | modevent (const Delta &d) |
| Return modification event. | |
Domain cache operations | |
|
| |
| void | initCache (Space &home, const IntSet &glb, const IntSet &lub) |
| Initialize cache to bounds glb and lub. | |
| void | cacheGlb (Space &home) |
| Update greatest lower bound cache to current domain. | |
| void | cacheLub (Space &home) |
| Update least upper bound cache to current domain. | |
| bool | glbModified (void) const |
| Check whether greatest lower bound cache differs from current domain. | |
| bool | lubModified (void) const |
| Check whether least upper bound cache differs from current domain. | |
Cloning | |
|
| |
| void | update (Space &home, bool share, CachedView< View > &y) |
| Update this view to be a clone of view y. | |
View-dependent propagator support | |
|
| |
| static void | schedule (Space &home, Propagator &p, ModEvent me) |
| Schedule propagator p with modification event me. | |
| static ModEvent | me (const ModEventDelta &med) |
| Return modification event for view type in med. | |
| static ModEventDelta | med (ModEvent) |
| Translate modification event me to modification event delta for view. |
Detailed Description
template<class View>
class Gecode::Set::CachedView< View >
Cached set view.
A cached set view for a set view adds operations for cacheing the current domain of and comparing the current domain to the cached domain. Cached views make it easy to implement incremental propagation algorithms.
Definition at line 921 of file view.hpp.
Constructor & Destructor Documentation
| Gecode::Set::CachedView< View >::CachedView | ( | void | ) |
Default constructor.
| Gecode::Set::CachedView< View >::CachedView | ( | const View & | y | ) | [explicit] |
Initialize with set view y.
Member Function Documentation
| unsigned int Gecode::Set::CachedView< View >::cardMin | ( | void | ) | const |
Return minimum cardinality.
| unsigned int Gecode::Set::CachedView< View >::cardMax | ( | void | ) | const |
Return maximum cardinality.
| int Gecode::Set::CachedView< View >::lubMin | ( | void | ) | const |
Return minimum of the least upper bound.
| int Gecode::Set::CachedView< View >::lubMax | ( | void | ) | const |
Return maximum of the least upper bound.
| int Gecode::Set::CachedView< View >::lubMinN | ( | unsigned int | n | ) | const |
Return n-th smallest element of the least upper bound.
| int Gecode::Set::CachedView< View >::glbMin | ( | void | ) | const |
Return minimum of the greatest lower bound.
| int Gecode::Set::CachedView< View >::glbMax | ( | void | ) | const |
Return maximum of the greatest lower bound.
| unsigned int Gecode::Set::CachedView< View >::glbSize | ( | void | ) | const |
Return the number of elements in the greatest lower bound.
| unsigned int Gecode::Set::CachedView< View >::lubSize | ( | void | ) | const |
Return the number of elements in the least upper bound.
| unsigned int Gecode::Set::CachedView< View >::unknownSize | ( | void | ) | const |
Return the number of unknown elements.
| bool Gecode::Set::CachedView< View >::contains | ( | int | i | ) | const |
Test whether i is in the greatest lower bound.
| bool Gecode::Set::CachedView< View >::notContains | ( | int | i | ) | const |
Test whether i is not in the least upper bound.
| ModEvent Gecode::Set::CachedView< View >::cardMin | ( | Space & | home, | |
| unsigned int | m | |||
| ) |
Restrict cardinality to be greater than or equal to m.
| ModEvent Gecode::Set::CachedView< View >::cardMax | ( | Space & | home, | |
| unsigned int | m | |||
| ) |
Restrict cardinality to be less than or equal to m.
| ModEvent Gecode::Set::CachedView< View >::include | ( | Space & | home, | |
| int | i, | |||
| int | j | |||
| ) |
Update greatest lower bound to include all elements between and including i and j.
| ModEvent Gecode::Set::CachedView< View >::exclude | ( | Space & | home, | |
| int | i, | |||
| int | j | |||
| ) |
Restrict least upper bound to not contain all elements between and including i and j.
| ModEvent Gecode::Set::CachedView< View >::include | ( | Space & | home, | |
| int | i | |||
| ) |
Update greatest lower bound to contain i.
| ModEvent Gecode::Set::CachedView< View >::exclude | ( | Space & | home, | |
| int | i | |||
| ) |
Restrict least upper bound to not contain i.
| ModEvent Gecode::Set::CachedView< View >::intersect | ( | Space & | home, | |
| int | i, | |||
| int | j | |||
| ) |
Update least upper bound to contain at most all elements between and including i and j.
| ModEvent Gecode::Set::CachedView< View >::intersect | ( | Space & | home, | |
| int | i | |||
| ) |
Update least upper bound to contain at most the element i.
| ModEvent Gecode::Set::CachedView< View >::excludeI | ( | Space & | home, | |
| I & | i | |||
| ) | [inline] |
Remove range sequence described by i from least upper bound.
| ModEvent Gecode::Set::CachedView< View >::includeI | ( | Space & | home, | |
| I & | i | |||
| ) | [inline] |
Include range sequence described by i in greatest lower bound.
| ModEvent Gecode::Set::CachedView< View >::intersectI | ( | Space & | home, | |
| I & | iter | |||
| ) | [inline] |
Intersect least upper bound with range sequence described by i.
| static void Gecode::Set::CachedView< View >::schedule | ( | Space & | home, | |
| Propagator & | p, | |||
| ModEvent | me | |||
| ) | [static] |
Schedule propagator p with modification event me.
Reimplemented from Gecode::DerivedView< View >.
| static ModEvent Gecode::Set::CachedView< View >::me | ( | const ModEventDelta & | med | ) | [static] |
Return modification event for view type in med.
Reimplemented from Gecode::DerivedView< View >.
| static ModEventDelta Gecode::Set::CachedView< View >::med | ( | ModEvent | ) | [static] |
Translate modification event me to modification event delta for view.
Reimplemented from Gecode::DerivedView< View >.
| void Gecode::Set::CachedView< View >::subscribe | ( | Space & | home, | |
| Propagator & | p, | |||
| PropCond | pc, | |||
| bool | schedule = true | |||
| ) |
Subscribe propagator p with propagation condition pc to view.
In case schedule is false, the propagator is just subscribed but not scheduled for execution (this must be used when creating subscriptions during propagation).
Reimplemented from Gecode::DerivedView< View >.
| void Gecode::Set::CachedView< View >::cancel | ( | Space & | home, | |
| Propagator & | p, | |||
| PropCond | pc | |||
| ) |
Cancel subscription of propagator p with propagation condition pc to view.
Reimplemented from Gecode::DerivedView< View >.
| void Gecode::Set::CachedView< View >::subscribe | ( | Space & | home, | |
| Advisor & | a | |||
| ) |
Subscribe advisor a to view.
Reimplemented from Gecode::DerivedView< View >.
| void Gecode::Set::CachedView< View >::cancel | ( | Space & | home, | |
| Advisor & | a | |||
| ) |
Cancel subscription of advisor a.
Reimplemented from Gecode::DerivedView< View >.
| static ModEvent Gecode::Set::CachedView< View >::modevent | ( | const Delta & | d | ) | [static] |
Return modification event.
Reimplemented from Gecode::DerivedView< View >.
| int Gecode::Set::CachedView< View >::glbMin | ( | const Delta & | d | ) | const |
Return minimum value just pruned from glb.
| int Gecode::Set::CachedView< View >::glbMax | ( | const Delta & | d | ) | const |
Return maximum value just pruned from glb.
| bool Gecode::Set::CachedView< View >::glbAny | ( | const Delta & | d | ) | const |
Test whether arbitrary values got pruned from glb.
| int Gecode::Set::CachedView< View >::lubMin | ( | const Delta & | d | ) | const |
Return minimum value just pruned from lub.
| int Gecode::Set::CachedView< View >::lubMax | ( | const Delta & | d | ) | const |
Return maximum value just pruned from lub.
| bool Gecode::Set::CachedView< View >::lubAny | ( | const Delta & | d | ) | const |
Test whether arbitrary values got pruned from lub.
| void Gecode::Set::CachedView< View >::initCache | ( | Space & | home, | |
| const IntSet & | glb, | |||
| const IntSet & | lub | |||
| ) |
Initialize cache to bounds glb and lub.
| void Gecode::Set::CachedView< View >::cacheGlb | ( | Space & | home | ) |
Update greatest lower bound cache to current domain.
| void Gecode::Set::CachedView< View >::cacheLub | ( | Space & | home | ) |
Update least upper bound cache to current domain.
| bool Gecode::Set::CachedView< View >::glbModified | ( | void | ) | const |
Check whether greatest lower bound cache differs from current domain.
| bool Gecode::Set::CachedView< View >::lubModified | ( | void | ) | const |
Check whether least upper bound cache differs from current domain.
| void Gecode::Set::CachedView< View >::update | ( | Space & | home, | |
| bool | share, | |||
| CachedView< View > & | y | |||
| ) |
Update this view to be a clone of view y.
| ModEvent Gecode::Set::CachedView< View >::excludeI | ( | Space & | home, | |
| I & | iter | |||
| ) | [inline] |
Definition at line 163 of file cached.hpp.
| ModEvent Gecode::Set::CachedView< View >::includeI | ( | Space & | home, | |
| I & | iter | |||
| ) | [inline] |
Definition at line 169 of file cached.hpp.
| ModEvent Gecode::Set::CachedView< View >::intersectI | ( | Space & | home, | |
| I & | iter | |||
| ) | [inline] |
Definition at line 175 of file cached.hpp.
Member Data Documentation
LUBndSet Gecode::Set::CachedView< View >::lubCache [protected] |
GLBndSet Gecode::Set::CachedView< View >::glbCache [protected] |
The documentation for this class was generated from the following files:
- gecode/set/view.hpp (Revision: 12318)
- gecode/set/view/cached.hpp (Revision: 12201)


Soul Guide Udan Mardui:
I sensed the magical power of the Ketra Orcs getting weaker. Was your mission a success?
"Here's the heart of flame."


Let yourself be seen first among hundreds of other applicants. With priority application, you’ll be distinguished as a candidate who’s committed and serious about your career growth.
With Priority Application, you automatically get highlighted with a Priority Label and be placed on top of the employer’s applicants list, so employers see you first!
Employers will get personal email notification and give your application preferred consideration. You will also receive email alerts when employers view your resume.
With JobStreet.com’s Priority Application you will be
taking an additional step to stand out amongst all the other applicants


{% load render_nan %}
| Sponsor name | Trials on EUCTR | Trials due to report results | % Reported | Trials with inconsistent data | Major? | |
|---|---|---|---|---|---|---|
| {{ sponsor.sponsor_name }} | {{ sponsor.total_trials }} | {{ sponsor.total_due }} | {{ sponsor.percent_reported | custom_percent }} | {{ sponsor.inconsistent_trials }} | {% if sponsor.major %}major | {% else %}minor | {% endif %}


Apply-Nigeria is an online web application designed to guide its users in the process of discovering and selecting suitable academic institutions that meets their individual requirements.
Together with our partners, we strive to provide quality and reliable information for our customers. Information found on this site has been vetted, verified, and is 100% accurate.
At Apply-Nigeria, we value leadership, integrity and service. It is our vision to be the hub of all school related information necessary for the school application process. Our mission statement is to remain market leaders that provide independent qualitative, reliable and accurate school related information.


on the gripping hand
`Prev `__
O
`Next `__
--------------
**on the gripping hand**
In the progression that starts “On the one hand...” and continues “On
the other hand...” mainstream English may add “on the third hand...”
even though most people don't have three hands. Among hackers, it is
just as likely to be “on the gripping hand”. This metaphor supplied the
title of Larry Niven & Jerry Pournelle's 1993 SF novel “The Gripping
Hand” which involved a species of hostile aliens with three arms (the
same species, in fact, referenced in `*juggling
eggs* <../J/juggling-eggs.html>`__). As with
`*TANSTAAFL* <../T/TANSTAAFL.html>`__ and `*con* <../C/con_.html>`__,
this usage became one of the naturalized imports from SF fandom
frequently observed among hackers.
--------------
+----------------------------------+----------------------------+---------------------------------------+
| `Prev `__ | `Up <../O.html>`__ | `Next `__ |
+----------------------------------+----------------------------+---------------------------------------+
| Old Testament | `Home <../index.html>`__ | one-banana problem |
+----------------------------------+----------------------------+---------------------------------------+


The Boost C++ Libraries
This book is licensed under a Creative Commons License.
The library Boost.Filesystem simplifies working with files and directories. It provides a class named boost::filesystem::path
that allows to process paths. In addition, many functions are available to create directories or to validate a given file for example.
boost::filesystem::path
is the central class in Boost.Filesystem representing path information and providing methods to process them.
In particular, boost::filesystem::path
is actually a typedef
for boost::filesystem::basic_path<std::string>
. Additionally, boost::filesystem::wpath
is provided as a typedef
for boost::filesystem::basic_path<std::wstring>
.
All definitions are part of the boost::filesystem namespace which is defined in boost/filesystem.hpp
.
Paths can be built by passing a corresponding string to the boost::filesystem::path
class.
#include <boost/filesystem.hpp> int main() { boost::filesystem::path p1("C:\\"); boost::filesystem::path p2("C:\\Windows"); boost::filesystem::path p3("C:\\Program Files"); }
None of the constructors of boost::filesystem::path
actually validates the path provided or checks whether or not the given file or directory exists. Thus, boost::filesystem::path
can be instantiated even with meaningless paths.
#include <boost/filesystem.hpp> int main() { boost::filesystem::path p1("..."); boost::filesystem::path p2("\\"); boost::filesystem::path p3("@:"); }
The reason the above program can be executed without any issue is that paths are just strings. boost::filesystem::path
only processes strings; the file system is not being accessed.
boost::filesystem::path
certainly provides methods to retrieve a path as a string. Interestingly, there are three different methods available.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\Windows\\System"); std::cout << p.string() << std::endl; std::cout << p.file_string() << std::endl; std::cout << p.directory_string() << std::endl; }
The string()
method returns a so-called portable path. In other words, Boost.Filesystem uses its own predefined rules to normalize the given string. In the above example, string()
returns C:/Windows/System
. As can be seen, Boost.Filesystem internally uses the slash character /
as the separator for file and directory names.
The whole purpose of portable paths is to uniquely identify files and directories across different platforms such as Windows or Linux. The usage of preprocessor macros to encode paths depending on the underlying operating system is therefore no longer needed. The rules for building portable paths mostly comply with the POSIX standard and are outlined in the Boost.Filesystem reference.
Please note that the constructor of boost::filesystem::path
supports both portable and platform dependent paths. The path "C:\\Windows\\System" used in the above example is not portable but rather specific to Windows. It will be recognized correctly by Boost.Filesystem but only if the program is executed on the Windows operating system! When executed on a POSIX compliant operating system such as Linux, string()
will actually return C:\Windows\System
. Since the backslash character \
in Linux is not used as a separator in neither the portable nor the native format, Boost.Filesystem does not recognize it as being a separator for files and directories either.
Many times, it will be inevitable to use platform dependent paths as strings. One example is the usage of operating system functions that expect a platform dependent encoding. The file_string()
and directory_string()
methods are offered for exactly this purpose.
Both methods return C:\Windows\System
in the above example - independent of the underlying operating system. While the string is a valid path on Windows, it is neither portable nor platform dependent on a Linux system as explained in the previous section.
The following example uses a portable path to initialize boost::filesystem::path
.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("/"); std::cout << p.string() << std::endl; std::cout << p.file_string() << std::endl; std::cout << p.directory_string() << std::endl; }
Since string()
returns a portable path, it equals the one used to initialize boost::filesystem::path
: /
. The file_string()
and directory_string()
methods, however, return different results based on the underlying platform. In Windows, both return \
while in Linux, both return /
instead.
One might wonder why there are two different methods returning platform dependent paths. Until now, file_string()
and directory_string()
always returned the same value in the shown examples. However, there are operating systems that may return different results. Since Boost.Filesystem aims to support as many operating systems as possible, it actually provides two methods to accommodate accordingly. Even though one may be more familiar with Windows or POSIX systems such as Linux, it is recommended to use file_string()
for retrieving path information for files and directory_string()
for retrieving path information for directories, respectively. This certainly increases the portability of the code.
boost::filesystem::path
provides several methods to access certain components of a path.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\Windows\\System"); std::cout << p.root_name() << std::endl; std::cout << p.root_directory() << std::endl; std::cout << p.root_path() << std::endl; std::cout << p.relative_path() << std::endl; std::cout << p.parent_path() << std::endl; std::cout << p.filename() << std::endl; }
If executed on a Windows operating system, the string "C:\\Windows\\System" is interpreted as a platform dependent path information. Consequently, root_name()
returns C:
, root_directory()
returns /
, root_path()
returns C:/
, relative_path()
returns Windows/System
, parent_path()
returns C:/Windows
, and filename()
returns System
.
As seen, no platform dependent path information is returned. None of the returned values contains a backslash \
but rather a slash /
. If platform dependent information is required, file_string()
or directory_string()
should be used instead. In order to use these methods on individual components of a path, a new object of type boost::filesystem::path
must be created and initialized accordingly.
If the above program is executed on a Linux operating system instead, the returned values are different. Most of the methods return an empty character stream except relative_path()
and filename()
which return C:\Windows\System
instead. Thus, the string "C:\\Windows\\System" is interpreted as a file name in Linux which is understandable given that it is neither a portable encoding of a path nor a platform depending encoding supported by Linux. Boost.Filesystem therefore has no other choice than interpreting the complete string as a file name.
Boost.Filesystem also provides additional methods to verify whether a specific substring is contained within a path. These methods are: has_root_name()
, has_root_directory()
, has_root_path()
, has_relative_path()
, has_parent_path()
and has_filename()
. Each method returns a value of type bool
.
There are two more methods used to split a file name into its components. These should only be applied if has_filename()
returned true
though. Otherwise, they will simply return empty strings since if there is no file name, there is nothing to split.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("photo.jpg"); std::cout << p.stem() << std::endl; std::cout << p.extension() << std::endl; }
The program returns photo
for stem()
as well as .jpg
for extension()
, respectively.
Instead of accessing the components of a path via method calls, one can also iterate over the components itself.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\Windows\\System"); for (boost::filesystem::path::iterator it = p.begin(); it != p.end(); ++it) std::cout << *it << std::endl; }
If executed on Windows, the program will successively output C:
, /
, Windows
and System
. On a different operating system such as Linux, the output will rather be C:\Windows\System
.
While the previous examples showed various methods to access different components of a path, the following example shows a method to modify path information instead.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\"); p /= "Windows\\System"; std::cout << p.string() << std::endl; }
Using the overloaded operator/=()
operator, the example appends a path to another one. In Windows, the program will output C:\Windows\System
accordingly. In Linux, the output will rather be C:\/Windows\System
since the slash character /
is the separator for files and directories. The slash is also the reason for overloading the operator/=()
operator: After all, the slash is part of the method name.
Besides the operator/=()
, Boost.Filesystem offers only the remove_filename()
and replace_extension()
methods for modifying path information.
The methods presented with boost::filesystem::path
internally simply process strings. They allow to access individual components of a path, appending paths to each other and so on.
In order to work with physical files and directories on the hard drive, several independent functions are provided. They expect one or more parameters of type boost::filesystem::path
and call operating system functions for the passed files or directories internally.
Prior to introducing different functions, it is important to understand what happens in the case of an error. All of the functions access operating system functions internally that certainly can fail. In case of a failure, an exception of type boost::filesystem::filesystem_error
will be thrown. This class is derived from boost::system::system_error
and thus fits itself within the Boost.System framework.
Apart from the what()
and code()
methods, inherited from the parent class boost::system::system_error
, two additional methods are available: path1()
and path2()
. Both return an object of type boost::filesystem::path
so that path information can be determined easily in case of an error - even while working with functions expecting two parameters of type boost::filesystem::path
.
Many functions exist in two variations: One throwing an exception of type boost::filesystem::filesystem_error
while the other returns an object of type boost::system::error_code
in case of a failure. For the latter one, the return value needs to be explicitly inspected to determine a failure.
The following example introduces a function that allows to query the status of a file or directory.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\"); try { boost::filesystem::file_status s = boost::filesystem::status(p); std::cout << boost::filesystem::is_directory(s) << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
boost::filesystem::status()
returns an object of type boost::filesystem::file_status
that can be passed to additional helper functions for evaluation. For example, boost::filesystem::is_directory()
will return true
if the status for a directory was queried. Besides boost::filesystem::is_directory()
, other functions such as boost::filesystem::is_regular_file()
, boost::filesystem::is_symlink()
and boost::filesystem::exists()
are available, all returning a value of type bool
.
Apart from boost::filesystem::status()
, a second function named boost::filesystem::symlink_status()
exists that can be used to query the status of a symbolic link. In this case, the status of the file referred to by the symbolic link is actually queried. In Windows, symbolic links are recognized by the lnk
file extension.
A different category of functions allows to query the attributes instead.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\Windows\\win.ini"); try { std::cout << boost::filesystem::file_size(p) << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
The boost::filesystem::file_size()
function returns the size of a file in bytes.
#include <boost/filesystem.hpp> #include <iostream> #include <ctime> int main() { boost::filesystem::path p("C:\\Windows\\win.ini"); try { std::time_t t = boost::filesystem::last_write_time(p); std::cout << std::ctime(&t) << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
To determine the time a file was modified last, boost::filesystem::last_write_time()
is used.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\"); try { boost::filesystem::space_info s = boost::filesystem::space(p); std::cout << s.capacity << std::endl; std::cout << s.free << std::endl; std::cout << s.available << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
boost::filesystem::space()
is used to retrieve the total and remaining disk space. It returns an object of type boost::filesystem::space_info
that defines three public properties: capacity, free and available. All properties are of type boost::uintmax_t
which is defined in the Boost.Integer library and is typically a typedef for unsigned long long
. The disk space is therefore calculated in bytes.
While all functions presented so far leave files and directories untouched, there exist several functions that allow to create, rename or delete files and directories.
#include <boost/filesystem.hpp> #include <iostream> int main() { boost::filesystem::path p("C:\\Test"); try { if (boost::filesystem::create_directory(p)) { boost::filesystem::rename(p, "C:\\Test2"); boost::filesystem::remove("C:\\Test2"); } } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
The above example should be self-explanatory. By looking closely, it can be seen that not always an object of type boost::filesystem::path
is passed to the individual function but rather a simple string. This is actually possible since boost::filesystem::path
offers a non-explicit constructor which will convert simple strings to objects of type boost::filesystem::path
internally. This actually simplifies the usage of Boost.Filesystem since the creation of explicit objects is not required.
Additional functions such as create_symlink()
to create a symbolic link or copy_file()
to copy a file or directory are available as well.
The following example presents a function that creates an absolute path based on a file name or section of a path.
#include <boost/filesystem.hpp> #include <iostream> int main() { try { std::cout << boost::filesystem::complete("photo.jpg") << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
Which path is actually displayed depends on the directory the program is executed within. If for example executed from within C:\
, the output will be C:/photo.jpg
.
Please note again the slash character /
! If a platform dependent path is desired, an object of type boost::filesystem::path
needs to be initialized and file_string()
must be called.
To retrieve an absolute path relative to a different directory, a second parameter can be passed to boost::filesystem::complete()
.
#include <boost/filesystem.hpp> #include <iostream> int main() { try { std::cout << boost::filesystem::complete("photo.jpg", "D:\\") << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
Now the program displays D:/photo.jpg
.
Finally, a useful helper function to retrieve the current working directory is shown in the following example.
#include <windows.h> #include <boost/filesystem.hpp> #include <iostream> int main() { try { std::cout << boost::filesystem::current_path() << std::endl; SetCurrentDirectory("C:\\"); std::cout << boost::filesystem::current_path() << std::endl; } catch (boost::filesystem::filesystem_error &e) { std::cerr << e.what() << std::endl; } }
The above program can only be executed in Windows due to the SetCurrentDirectory()
function. This function modifies the current working directory so that both calls to boost::filesystem::current_path()
return different results.
There exists a boost::filesystem::initial_path()
function returning the directory from within the application has been started. However, this function depends on additional support from the operating system and thus is not recommended if portability is required. In this case, the return value of boost::filesystem::current_path()
should be saved at the beginning of the program for future use as recommended by the documentation for Boost.Filesystem.
The C++ standard defines various file streams in the fstream
header. These streams certainly do not accept a parameter of type boost::filesystem::path
. Since the Boost.Filesystem library will most likely be included in the Technical Report 2 of the C++ standard, the file streams will be extended by corresponding constructors though. In order to currently work with file streams and path information of type boost::filesystem::path
, the header boost/filesystem/fstream.hpp
can be accessed. It provides the required additions to file streams that will be added to the C++ standard in the future based on the Technical Report 2.
#include <boost/filesystem/fstream.hpp> #include <iostream> int main() { boost::filesystem::path p("test.txt"); boost::filesystem::ofstream ofs(p); ofs << "Hello, world!" << std::endl; }
Not only the constructors but also the overloaded open()
methods accept parameters of type boost::filesystem::path
.
You can buy solutions to all exercises in this book as a ZIP file.
Create a program that creates an absolute path for a file named data.txt
that resides in a directory one level above the current working directory of the application. For example, if the program is executed from within C:\Program Files\Test
, it should display C:\Program Files\data.txt
accordingly.
Copyright © 2008-2010 Boris Schäling


Prerequisites
Introduction
A port scanner is a program which probes a server for open ports by attempting a connection to the server via each port in turn. The program usually then reports which ports were open and which were closed. More complex port scanners, such as Nmap, can probe for other information as well. Port scanning is usually performed by system administrators to verify network security or by attackers looking for an open port through which to compromise the security of a server. Open ports may constitute security vulnerabilities as they allow remote machines to connect. Unexpectedly-open ports may indicate malicious software listening for instructions.
My First Port Scanner
As before, scanning ports is as simple as attempting a connection to an address and port. If the connection attempt is successful, the port must be open. Otherwise the port is presumed to be closed. Here is an example function using the SFML Network module (
documentation) to check if a port is open:
1 2 3 4 5 6 7
|
bool port_is_open(const std::string& address, int port)
{
sf::TcpSocket socket;
bool open = (socket.connect(sf::IpAddress(address), port) == sf::Socket::Done);
socket.disconnect();
return open;
}
| |
Breakdown:
- First, we create an instance of sf::TcpSocket (documentation) which allows us to connect to a remote socket
- Then, we connect the socket. We convert the string 'address' to an sf::IpAddress (documentation) instance by calling the constructor for sf::IpAddress. If the explicit constructor call is left out, it will be performed implicitly by the compiler anyway. After attempting a connection we check whether the connection succeeded by comparing the return value of the sf::TcpSocket::connect function (documentation) with the enumerator value sf::Socket::Done (documentation). If the two are equal, it means the connection succeeded and the port is open. In this case, the variable 'open' is set to true.
- Next, we disconnect the socket using the sf::TcpSocket::disconnect function (documentation). This would be done automatically in the destructor if we left the explicit call out.
- Finally, we return the value of 'open' to the calling function.
This is actually the only networking code we need to write. We can also simplify it to a single line:
1 2 3 4
|
static bool port_is_open(const std::string& address, int port)
{
return (sf::TcpSocket().connect(address, port) == sf::Socket::Done);
}
| |
Here we're creating a new sf::TcpSocket, connecting to the address and port and then returning true or false depending on whether the connection succeeded. We get rid of the unneeded explicit sf::IpAddress constructor call as well as the call to sf::TcpSocket::disconnect(). We can use the function in a program like this:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
|
#include <iostream>
#include <SFML/Network.hpp>
#include <string>
static bool port_is_open(const std::string& address, int port)
{
return (sf::TcpSocket().connect(address, port) == sf::Socket::Done);
}
int main()
{
std::cout << "Port 80 : ";
if (port_is_open("localhost", 80))
std::cout << "OPEN" << std::endl;
else
std::cout << "CLOSED" << std::endl;
return 0;
}
|
Port 80 : OPEN | |
Try compiling and running this program. It will test if port 80 on your computer is open. Note that "localhost" means the local computer; you can also use the IP address <IP_ADDRESS> or ::1 (the IPv6 version, although SFML does not yet support IPv6) for the same purpose. You can change "localhost" to the IP address or web address of another website (leaving out the "http://" and any path information), but be careful -
portscanning websites without permission can get you into trouble in some countries as it can be considered hacking. Luckily the website of the port scanner Nmap has a page specifically for testing port scanners. Try changing "localhost" to "scanme.nmap.org". Just don't scan it too much (the page says "a few times per day").
Improved Port Scanner
Now that we've successfully developed a program that can scan a port on an address, we can modify our program to let the user specify a port and address to scan:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
|
#include <iostream>
#include <SFML/Network.hpp>
#include <string>
static bool port_is_open(const std::string& address, int port)
{
return (sf::TcpSocket().connect(address, port) == sf::Socket::Done);
}
int main()
{
std::string address;
int port;
// Get the address.
std::cout << "Address: " << std::flush;
std::getline(std::cin, address);
// Get the port.
std::cout << "Port: " << std::flush;
std::cin >> port;
// Scan!
std::cout << "Scanning " << address << "...\n" << "Port " << port << " : ";
if (port_is_open(address, port))
std::cout << "OPEN" << std::endl;
else
std::cout << "CLOSED" << std::endl;
return 0;
}
|
Address: <IP_ADDRESS>
Port: 80
Scanning <IP_ADDRESS>...
Port 80 : OPEN | |
Remember that <IP_ADDRESS> is equivalent to localhost. Also, port 80 may not be open on your computer. It's only open on mine because I'm running Apache HTTP server (port 80 is the main port commonly used for HTTP, i.e. websites; the other port commonly used for HTTP is port 8080).
Also, we can easily test this code on Nmap's "ScanMe" page:
Address: scanme.nmap.org
Port: 80
Scanning scanme.nmap.org...
Port 80 : OPEN |
It might take slightly longer this time because you aren't scanning your own computer, this time you're connecting to another computer via the Internet.
A Fistful of Ports
Scanning one port at a time is tedious, we want to let the user scan lots of ports. One way to do this would be to let the user enter as many ports as they want and then have them all scanned in one go. The problem with this is that the user might want to scan a lot of ports, and would have to enter each one. We could also let the user specify a range of ports, say, 0-100, but then they couldn't specify values outside of that range. We're going to go one better and let them do both - specify ranges AND individual ports in a list like this: '80,8080'; a range, like this: '20-80'; or a list containing ranges: '20-80,8080'. This code gets kind of complex due to the use of templates, std::vector, std::stringstream and the C++11 range-based for-loop, so if you skipped the "prerequisites" section and don't know how to use those, go back to the top of this article and learn. Otherwise, read on.
First we need a function to split strings:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
// Splits a string into tokens arround a delimiter (default: space),
// optionally allowing empty tokens.
static std::vector<std::string> split(const std::string& string,
char delimiter = ' ',
bool allow_empty = false)
{
std::vector<std::string> tokens;
std::stringstream sstream(string);
std::string token;
while (std::getline(sstream, token, delimiter)) {
if (allow_empty || token.size() > 0)
tokens.push_back(token);
}
return tokens;
}
| |
The data type of the ports will be a string, but we want an integer, so we will also need a function to convert strings to integers:
1 2 3 4 5 6 7 8
|
// Converts a string to an integer.
static int string_to_int(const std::string& string)
{
std::stringstream sstream(string);
int i;
sstream >> i;
return i;
}
| |
If we have a range of ports, we will need a function to generate all the values in that range:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
|
// Swaps two values.
template <typename T>
static void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
// Generates a vector containing a range of values.
template <typename T>
static std::vector<T> range(T min, T max)
{
if (min > max)
swap(min, max);
if (min == max)
return std::vector<T>(1, min);
std::vector<T> values;
for (; min <= max; ++min)
values.push_back(min);
return values;
}
| |
Finally, we need a function to actually parse the list of ports using the above functions:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
|
// Parses a list of ports containing numbers and ranges
static std::vector<int> parse_ports_list(const std::string& list)
{
std::vector<int> ports;
// Split list items.
for (const std::string& token : split(list, ',')) {
// Split ranges.
std::vector<std::string> strrange = split(token, '-');
switch (strrange.size()) {
// Only one value (add to end of 'ports').
case 0: ports.push_back(string_to_int(token)); break;
case 1: ports.push_back(string_to_int(strrange[0])); break;
// Two values (range - add everything in that range).
case 2:
{
int min = string_to_int(strrange[0]),
max = string_to_int(strrange[1]);
for (int port : range(min, max))
ports.push_back(port);
break;
}
default:
break;
}
}
return ports;
}
| |
Our finished program:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
|
#include <iostream>
#include <SFML/Network.hpp>
#include <sstream>
#include <string>
#include <vector>
static bool port_is_open(const std::string& address, int port)
{
return (sf::TcpSocket().connect(address, port) == sf::Socket::Done);
}
static std::vector<std::string> split(const std::string& string,
char delimiter = ' ',
bool allow_empty = false)
{
std::vector<std::string> tokens;
std::stringstream sstream(string);
std::string token;
while (std::getline(sstream, token, delimiter)) {
if (allow_empty || token.size() > 0)
tokens.push_back(token);
}
return tokens;
}
static int string_to_int(const std::string& string)
{
std::stringstream sstream(string);
int i;
sstream >> i;
return i;
}
template <typename T>
static void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
template <typename T>
static std::vector<T> range(T min, T max)
{
if (min > max)
swap(min, max);
if (min == max)
return std::vector<T>(1, min);
std::vector<T> values;
for (; min <= max; ++min)
values.push_back(min);
return values;
}
static std::vector<int> parse_ports_list(const std::string& list)
{
std::vector<int> ports;
for (const std::string& token : split(list, ',')) {
std::vector<std::string> strrange = split(token, '-');
switch (strrange.size()) {
case 0: ports.push_back(string_to_int(token)); break;
case 1: ports.push_back(string_to_int(strrange[0])); break;
case 2:
{
int min = string_to_int(strrange[0]),
max = string_to_int(strrange[1]);
for (int port : range(min, max))
ports.push_back(port);
break;
}
default:
break;
}
}
return ports;
}
int main()
{
std::string address;
std::string port_list;
std::vector<int> ports;
std::cout << "Address: " << std::flush;
std::getline(std::cin, address);
std::cout << "Port: " << std::flush;
std::getline(std::cin, port_list);
ports = parse_ports_list(port_list);
std::cout << "Scanning " << address << "...\n";
for (int port : ports) {
std::cout << "Port " << port << " : ";
if (port_is_open(address, port))
std::cout << "OPEN\n";
else
std::cout << "CLOSED\n";
}
std::cout << std::flush;
return 0;
}
|
Address: <IP_ADDRESS>
Port: 20-80,8080
Scanning <IP_ADDRESS>...
Port 20 : CLOSED
Port 21 : CLOSED
Port 22 : OPEN
Port 23 : CLOSED
Port 24 : CLOSED
Port 25 : CLOSED
Port 26 : CLOSED
Port 27 : CLOSED
Port 28 : CLOSED
Port 29 : CLOSED
Port 30 : CLOSED
Port 31 : CLOSED
Port 32 : CLOSED
Port 33 : CLOSED
Port 34 : CLOSED
Port 35 : CLOSED
Port 36 : CLOSED
Port 37 : CLOSED
Port 38 : CLOSED
Port 39 : CLOSED
Port 40 : CLOSED
Port 41 : CLOSED
Port 42 : CLOSED
Port 43 : CLOSED
Port 44 : CLOSED
Port 45 : CLOSED
Port 46 : CLOSED
Port 47 : CLOSED
Port 48 : CLOSED
Port 49 : CLOSED
Port 50 : CLOSED
Port 51 : CLOSED
Port 52 : CLOSED
Port 53 : OPEN
Port 54 : CLOSED
Port 55 : CLOSED
Port 56 : CLOSED
Port 57 : CLOSED
Port 58 : CLOSED
Port 59 : CLOSED
Port 60 : CLOSED
Port 61 : CLOSED
Port 62 : CLOSED
Port 63 : CLOSED
Port 64 : CLOSED
Port 65 : CLOSED
Port 66 : CLOSED
Port 67 : CLOSED
Port 68 : CLOSED
Port 69 : CLOSED
Port 70 : CLOSED
Port 71 : CLOSED
Port 72 : CLOSED
Port 73 : CLOSED
Port 74 : CLOSED
Port 75 : CLOSED
Port 76 : CLOSED
Port 77 : CLOSED
Port 78 : CLOSED
Port 79 : CLOSED
Port 80 : OPEN
Port 8080 : CLOSED | |
Et voila! We now have a successful port scanner which can scan any number of ports the user desires.
For a Few Ports More
Our program can be modified not to show closed ports by changing
89 90 91 92 93 94 95 96
|
std::cout << "Scanning " << address << "...\n";
for (int port : ports) {
std::cout << "Port " << port << " : ";
if (port_is_open(address, port))
std::cout << "OPEN\n";
else
std::cout << "CLOSED\n";
}
| |
to
89 90 91 92 93
|
std::cout << "Showing open ports on " << address << "...\n";
for (int port : ports) {
if (port_is_open(address, port))
std::cout << "Port " << port << " : OPEN\n";
}
| |
This makes the output far more legible. Scanning every port on my computer:
Address: localhost
Port: 0-65535
Showing open ports on localhost...
Port 22 : OPEN
Port 53 : OPEN
Port 80 : OPEN
Port 139 : OPEN
Port 445 : OPEN
Port 631 : OPEN
Port 3306 : OPEN
Port 17500 : OPEN |
Note that there are 65535 ports. If we scanned all of them with the previous version of the port scanner, it would produce 65,535 lines of output which would make it very difficult to get the desired information.
We can format our output nicely by adding
#include <iomanip>
at the top of the file, and
size_t width = digits(maximum(ports));
just before the for-loop in the main function, and then changing the line that displays the port status to
std::cout << "Port " << std::setw(width) << port << " : OPEN\n";
. You will also need to add these two functions just before main:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
|
// Gets the maximum value in a vector.
template <typename T>
static T maximum(const std::vector<T>& values)
{
T max = values[0];
for (T value : values) {
if (value > max)
max = value;
}
return max;
}
// Counts the digits in a number.
template <typename T>
static size_t digits(T value)
{
size_t count = (value < 0) ? 1 : 0;
if (value == 0)
return 0;
while (value) {
value /= 10;
++count;
};
return count;
}
| |
Now the output will be nicely formatted:
Address: localhost
Port: 0-65535
Showing open ports on localhost...
Port 22 : OPEN
Port 53 : OPEN
Port 80 : OPEN
Port 139 : OPEN
Port 445 : OPEN
Port 631 : OPEN
Port 3306 : OPEN
Port 17500 : OPEN
Port 35723 : OPEN
Port 43351 : OPEN |
Here is the code for our improved port scanner:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
|
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <SFML/Network.hpp>
#include <sstream>
#include <string>
#include <vector>
static bool port_is_open(const std::string& address, int port)
{
return (sf::SocketTCP().connect(address, port) == sf::Socket::Done);
}
static std::vector<std::string> split(const std::string& string,
char delimiter = ' ',
bool allow_empty = false)
{
std::vector<std::string> tokens;
std::stringstream sstream(string);
std::string token;
while (std::getline(sstream, token, delimiter)) {
if (allow_empty || token.size() > 0)
tokens.push_back(token);
}
return tokens;
}
static int string_to_int(const std::string& string)
{
std::stringstream sstream(string);
int i;
sstream >> i;
return i;
}
template <typename T>
static void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
template <typename T>
static std::vector<T> range(T min, T max)
{
if (min > max)
swap(min, max);
if (min == max)
return std::vector<T>(1, min);
std::vector<T> values;
for (; min <= max; ++min)
values.push_back(min);
return values;
}
static std::vector<int> parse_ports_list(const std::string& list)
{
std::vector<int> ports;
for (const std::string& token : split(list, ',')) {
std::vector<std::string> strrange = split(token, '-');
switch (strrange.size()) {
case 0: ports.push_back(string_to_int(token)); break;
case 1: ports.push_back(string_to_int(strrange[0])); break;
case 2:
{
int min = string_to_int(strrange[0]),
max = string_to_int(strrange[1]);
for (int port : range(min, max))
ports.push_back(port);
break;
}
default:
break;
}
}
return ports;
}
template <typename T>
static T maximum(const std::vector<T>& values)
{
T max = values[0];
for (T value : values) {
if (value > max)
max = value;
}
return max;
}
template <typename T>
static size_t digits(T value)
{
size_t count = (value < 0) ? 1 : 0;
if (value == 0)
return 0;
while (value) {
value /= 10;
++count;
};
return count;
}
int main()
{
std::string address;
std::string port_list;
std::vector<int> ports;
std::cout << "Address: " << std::flush;
std::getline(std::cin, address);
std::cout << "Port: " << std::flush;
std::getline(std::cin, port_list);
ports = parse_ports_list(port_list);
std::cout << "Showing open ports on " << address << "...\n";
size_t width = digits(maximum(ports));
for (int port : ports) {
if (port_is_open(address, port))
std::cout << "Port " << std::setw(width) << port << " : OPEN\n";
}
std::cout << std::flush;
return 0;
}
| |
You may want to be able to use the program easily in scripts and run it easily from other programs, in which case you can modify it to use command-line for the address and port information. Here is a modified main function:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
int main(int argc, char* argv[])
{
if (argc != 3) {
std::cerr << "Usage: " << argv[0] << " address port(s)\n"
<< "Examples:\n"
<< "\t" << argv[0] << " <IP_ADDRESS> 80\n"
<< "\t" << argv[0] << " localhost 80,8080\n"
<< "\t" << argv[0] << " <IP_ADDRESS> 0-65535\n"
<< "\t" << argv[0] << " example.com 0-21,80,8080"
<< std::endl;
std::exit(EXIT_FAILURE);
}
std::string address = argv[1];
std::vector<int> ports = parse_ports_list(std::string(argv[2]));
std::cout << "Showing open ports on " << address << "...\n";
size_t width = digits(maximum(ports));
for (int port : ports) {
if (port_is_open(address, port))
std::cout << "Port " << std::setw(width) << port << " : OPEN\";
}
std::cout << std::endl;
return 0;
}
| |
And here is one that allows both:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
|
int main(int argc, char* argv[])
{
std::string address;
std::vector<int> ports;
if (argc == 3) {
address = argv[1];
ports = parse_ports_list(std::string(argv[2]));
} else {
std::string port_list;
std::cout << "Address: " << std::flush;
std::getline(std::cin, address);
std::cout << "Port: " << std::flush;
std::getline(std::cin, port_list);
ports = parse_ports_list(port_list);
}
std::cout << "Showing open ports on " << address << "...\n";
size_t width = digits(maximum(ports));
for (int port : ports) {
if (port_is_open(address, port))
std::cout << "Port " << std::setw(width) << port << " : OPEN\n";
}
std::cout << std::flush;
return 0;
}
| |
Here is the final (for now) iteration of the port scanner, which allows both command-line and interactive invocation:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
|
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <SFML/Network.hpp>
#include <sstream>
#include <string>
#include <vector>
static bool port_is_open(const std::string& address, int port)
{
return (sf::SocketTCP().connect(address, port) == sf::Socket::Done);
}
static std::vector<std::string> split(const std::string& string,
char delimiter = ' ',
bool allow_empty = false)
{
std::vector<std::string> tokens;
std::stringstream sstream(string);
std::string token;
while (std::getline(sstream, token, delimiter)) {
if (allow_empty || token.size() > 0)
tokens.push_back(token);
}
return tokens;
}
static int string_to_int(const std::string& string)
{
std::stringstream sstream(string);
int i;
sstream >> i;
return i;
}
template <typename T>
static void swap(T& a, T& b)
{
T c = a;
a = b;
b = c;
}
template <typename T>
static std::vector<T> range(T min, T max)
{
if (min > max)
swap(min, max);
if (min == max)
return std::vector<T>(1, min);
std::vector<T> values;
for (; min <= max; ++min)
values.push_back(min);
return values;
}
static std::vector<int> parse_ports_list(const std::string& list)
{
std::vector<int> ports;
for (const std::string& token : split(list, ',')) {
std::vector<std::string> strrange = split(token, '-');
switch (strrange.size()) {
case 0: ports.push_back(string_to_int(token)); break;
case 1: ports.push_back(string_to_int(strrange[0])); break;
case 2:
{
int min = string_to_int(strrange[0]),
max = string_to_int(strrange[1]);
for (int port : range(min, max))
ports.push_back(port);
break;
}
default:
break;
}
}
return ports;
}
template <typename T>
static T maximum(const std::vector<T>& values)
{
T max = values[0];
for (T value : values) {
if (value > max)
max = value;
}
return max;
}
template <typename T>
static size_t digits(T value)
{
size_t count = (value < 0) ? 1 : 0;
if (value == 0)
return 0;
while (value) {
value /= 10;
++count;
};
return count;
}
int main(int argc, char* argv[])
{
std::string address;
std::vector<int> ports;
if (argc == 3) {
address = argv[1];
ports = parse_ports_list(std::string(argv[2]));
} else {
std::string port_list;
std::cout << "Address: " << std::flush;
std::getline(std::cin, address);
std::cout << "Port: " << std::flush;
std::getline(std::cin, port_list);
ports = parse_ports_list(port_list);
}
std::cout << "Showing open ports on " << address << "...\n";
size_t width = digits(maximum(ports));
for (int port : ports) {
if (port_is_open(address, port))
std::cout << "Port " << std::setw(width) << port << " : OPEN\n";
}
std::cout << std::flush;
return 0;
}
| |
Feel free to use or modify all the above code for any purpose (disclaimer: I will not be liable for any evil performed using my code).
Attached you can find the source of the original program that I wrote, which turned into the above code as I wrote the article. That program is distributed under the FreeBSD license.
To-Do
Attachments:
[cppscan.cpp]
[cppscan.h]
[main.cpp]


The following table contains header files used within the bit masks library extension. For additional information such as full descriptions, tutorials and interface guides please use the table of contents above.
|
Component |
Header |
Contence |
|---|---|---|
|
|
Header contains |
|
|
|
Header contains |
|
|
|
Header contains |
|
|
|
Header contains includes for |
|
|
|
Header contains |
|
|
|
Contains the |
|
|
|
Header contains |
|
|
|
Header contains a forward declaration for |


Welcome to CordHost
To view and make posts, visit your
Profile
page and if you want to see your friends list, go to your
Friends
page.


{{errorMessage}}
Login
Username
- User name is required.
- Remove spaces in user name.
- User name may only contain alphabetical and numerical characters.
Password
- Password is required.
- Password is not valid.
- Password does not meet minimum characters.
Submit


This is my report page (hh13577, Candidate#66889).
- My favourites
- Simple and fluid design of my website layout and navigation.
- My Video created from Animoto.
- My Logo.
- My Car animation
- Event details Modal window
- Hanging up the logo over header and the content parts of my page.
- My planning to keep the look and feel as simple as possible, eventualy helped me save a lot of time.
- Searches
- XHTML5, CSS from W3 Schools and Stack Overflow.
- Adapted the basic navigation menu idea from Dopetrope Website.
- The form submissions are adapted from Dhiraj. The site provides them as pop up windows with transitional effects, but I have used the concept to display the hidden inline tags.
-
Event Data Modal Window I have adapted this to match my fluid deisgn and data display.
- Carousel using Responsive Slides. I have adapted it to make my own theme for it.
- JQuery for DOM manipulations and ease of accessing the html data
- Learnings and findings
- Standard ways to develop a website using XHTML5, CSS and CSS3.
- The input type="date" does not work in most of the browsers.
- For date, I could have used JQuery Datepicker instead, but that would have made the client side heavy in terms of image files and .js.
- The ogg video does not play audio in Firefox 23.+ versions.
- Long time
- Fluid design of the website
- Testing
- Designing the logo
- Tools and techniques used
- JEdit with XML, HTML and CSS plugins
- Gimp to deign the logo and other images used in the website: used the simple layered and blending techniques
- Inkscape to create Some images and favicon


Facts about Doggos
This is a picture of different kinds of doggos, there are at least TEN types discovered!
Most doggos have 4 legs
Many doggos have collars with their name or ID number on a tag.
The most common tag number is, MCA{C0PYING_1z_d@ng3r0us}. no one really knows why this is such a popular number
Doggos make good friends


Link and Node Dictionaries
After defining a network in RivGraph with rivgraph.classes.rivnetwork.compute_network()
, two dictionaries will be created:
links and nodes.
This page of the documentation will describe the keys present in these dictionaries.
Note
Not all dictionary key:value pairs are the same length as the number of links or nodes. Some dictionary key:value pairs contain meta-information about the network, or information that only applies to a subset of links/nodes. When the number of key:value pairs matches the number of links or nodes, then they are aligned such that the i’th index of any key:value pair refers to the same link or node.
The Links Dictionary
Links Key Values
N represents the number of links.
key |
type |
length |
description |
|---|---|---|---|
id |
orderedSet |
N |
unique link id assigned to each link not in a particular order and not guaranteed to skip some id’s |
conn |
list of 2-element lists |
N |
node ids at link endpoints. After running directionality these are in order i.e. [us_nodeid ds_nodeid] |
idx |
list of lists of ints |
N |
list of the pixel coordinates in index format (via np.ravel_index using the shape of the input binary image) |
n_networks |
int |
1 |
number of networks identified |
parallels |
list of lists |
varies |
each sublist contains all link ids of links forming a parallel set; i.e. links that start and end at the same node. |
wid_pix |
list of np.arrays |
N |
width at each pixel of each link (pixels defined by idx) |
len |
list |
N |
length of each link |
wid |
list |
N |
average width of each link |
len_adj |
list |
N |
length of each link adjusted for accuracy |
wid_adj |
list |
N |
width of each link adjusted for accuracy |
key |
type |
length |
description |
|---|---|---|---|
certain |
np.array |
N |
1 if the link’s direction has been set else 0 |
certain_order |
np.array |
N |
describes the order in which links were set. Lower certain_order corresponds to earlier-set links. |
certain_alg |
np.array |
N |
algorithm id of the algorithm ultimately used to set the link direction |
guess |
list of lists |
N |
guesses of the upstream node id for each link; corresponds to guess_alg |
guess_alg |
list of lists |
N |
algorithm id used to compute guess; corresponds to guess |
key |
type |
length |
description |
|---|---|---|---|
maxang |
np.array |
N |
??? |
cldists |
np.array |
N |
number of mesh-generated transects each link intersects |
clangs |
np.array |
N |
angle of the link with respect to the valley centerline in radians |
wid_pctdiff |
np.array |
N |
percent difference between the widest and narrowest pixels in a link |
key |
type |
length |
description |
|---|---|---|---|
slope |
list |
N |
slope computed from synthetic DEM; note that this has no physical basis and should not be interpreted as actual link slope |
Accessing Link Values
For example, if you know the link_id of the link you are interested in, you can get its index with links['id'].index(link_id)
.
The Nodes Dictionary
Nodes Key Values
M represents the number of nodes.
key |
type |
length |
description |
|---|---|---|---|
id |
orderedSet |
M |
unique node id assigned to each node not in a particular order and not guaranteed to skip some id’s |
conn |
list of lists |
M |
link ids of all links connected to this node |
idx |
list of lists of ints |
M |
list of the pixel coordinates in index format (via np.ravel_index using the shape of the input binary image) |
inlets |
list of ints |
varies |
node ids of all nodes identified as inlets |
outlets |
list of ints |
varies |
node ids of all nodes identified as outlets |
int_angle |
np.array |
M |
most interior angle of links connected to each node in degrees; computed via |
jtype |
np.array |
M |
junction type; either ‘c’ (confluence) or ‘b’ (bifurcation); computed via |
width_ratio |
np.array |
M |
ratio of wider link/narrower link for the two links used to compute int_angle; computed via |
Accessing Node Values
For example, if you wish to find the links connected to node_id == 66
, you can use nodes['conn'][nodes['id'].index(66)]
.


{% extends "cinemaple_email_transactional.html" %} {% load static %} {% block message %}
Hello {{ firstname }},
Your status for Movie Night location {{location}} has changed to Host. This means you have full control over the Movie Nights and users privileges of {{location}}.
Use your new user privilege and add a new Movie Night now:
|


References
| summary | ||
| public |
Expression is used to build filtering expressions, like those used in WHERE clauses. |
|
| public |
Measurement creates a reference to a particular measurement. |
|
| public |
C InfluxDB InfluxDB is the public interface to run queries against your database. |
|
| public |
C Pool The Pool maintains a list available Influx hosts and dispatches requests to them. |
|
| public |
An RequestError is returned as an error from requests that result in a 300 <= error code <= 500. |
|
| public |
An ServiceNotAvailableError is returned as an error from requests that result in a > 500 error code. |
|
| public |
A ResultError is thrown when a query generates errorful results from Influx. |
|
| private |
C Schema The Schema provides information and utilities for an InfluxDB measurement. |
|
| private |
F assertNoErrors(res: *): * Checks if there are any errors in the IResponse and, if so, it throws them. |
|
| private |
F parse(res: *, precision: *): * From parses out a response to a result or list of responses. |
|
| private |
F parseSingle(res: *, precision: *): * ParseSingle asserts that the response contains a single result, and returns that result. |
|
| private |
F coerceBadly(fields: *): * Coerces the field map to a set of writable values, a la coerceFields, using native guesses based on the field datatypes. |
backoff
| summary | ||
| public |
Constant Backoff |
|
| public |
Exponential Backoff |
grammar
| summary | ||
| public |
C Raw You can provide Raw values to Influx methods to prevent it from escaping your provided string. |
|
| private |
F castTimestamp(timestamp: *, precision: *): * Converts a timestamp to a string with the correct precision. |
|
| private |
F dateToTime(date: *, precision: *): * Converts a Date instance to a timestamp with the specified time precision. |
|
| private |
F formatDate(date: *): * FormatDate converts the Date instance to Influx's date query format. |
|
| private |
F isoOrTimeToDate(stamp: *, precision: string): * Converts an ISO-formatted data or unix timestamp to a Date instance. |
|
| public |
F toNanoDate(timestamp: *): * Covers a nanoseconds unix timestamp to a INanoDate for node-influx. |
|
| public |
TagEscaper escapes tag keys, tag values, and field keys. |
|
| public |
Precision is a map of available Influx time precisions. |
|
| public |
FieldType is an enumeration of InfluxDB field data types. |


At Slydio, accessible from slyd.io, one of our main priorities is the privacy of our visitors. This Privacy Policy document contains types of information that is collected and recorded by Slydio and how we use it.
If you have additional questions or require more information about our Privacy Policy, do not hesitate to contact us.
Slydio follows a standard procedure of using log files. These files log visitors when they visit websites. All hosting companies do this and a part of hosting services' analytics. The information collected by log files include internet protocol (IP) addresses, browser type, Internet Service Provider (ISP), date and time stamp, referring/exit pages, and possibly the number of clicks. These are not linked to any information that is personally identifiable. The purpose of the information is for analyzing trends, administering the site, tracking users' movement on the website, and gathering demographic information.
Like any other website, Slydio uses 'cookies'. These cookies are used to store information including visitors' preferences, and the pages on the website that the visitor accessed or visited. The information is used to optimize the users' experience by customizing our web page content based on visitors' browser type and/or other information.
Google is one of a third-party vendor on our site. It also uses cookies, known as DART cookies, to serve ads to our site visitors based upon their visit to www.website.com and other sites on the internet. However, visitors may choose to decline the use of DART cookies by visiting the Google ad and content network Privacy Policy at the following URL – https://policies.google.com/technologies/ads
Some of advertisers on our site may use cookies and web beacons. Our advertising partners are listed below. Each of our advertising partners has their own Privacy Policy for their policies on user data. For easier access, we hyperlinked to their Privacy Policies below.
You may consult this list to find the Privacy Policy for each of the advertising partners of Slydio.
Third-party ad servers or ad networks uses technologies like cookies, JavaScript, or Web Beacons that are used in their respective advertisements and links that appear on Slydio, which are sent directly to users' browser. They automatically receive your IP address when this occurs. These technologies are used to measure the effectiveness of their advertising campaigns and/or to personalize the advertising content that you see on websites that you visit.
Note that Slydio has no access to or control over these cookies that are used by third-party advertisers.
Slydio's Privacy Policy does not apply to other advertisers or websites. Thus, we are advising you to consult the respective Privacy Policies of these third-party ad servers for more detailed information. It may include their practices and instructions about how to opt-out of certain options. You may find a complete list of these Privacy Policies and their links here: Privacy Policy Links.
You can choose to disable cookies through your individual browser options. To know more detailed information about cookie management with specific web browsers, it can be found at the browsers' respective websites. What Are Cookies?
Another part of our priority is adding protection for children while using the internet. We encourage parents and guardians to observe, participate in, and/or monitor and guide their online activity.
Slydio does not knowingly collect any Personal Identifiable Information from children under the age of 13. If you think that your child provided this kind of information on our website, we strongly encourage you to contact us immediately and we will do our best efforts to promptly remove such information from our records.
This Privacy Policy applies only to our online activities and is valid for visitors to our website with regards to the information that they shared and/or collect in Slydio. This policy is not applicable to any information collected offline or via channels other than this website.
By using our website, you hereby consent to our Privacy Policy and agree to its Terms and Conditions.


Download the loan application records (LAR) for the current Lender/MSA/Year combination:
Download CSV
Loading Data


001 /* 002 * Copyright (C) 2006 Google Inc. 003 * 004 * Licensed under the Apache License, Version 2.0 (the "License"); 005 * you may not use this file except in compliance with the License. 006 * You may obtain a copy of the License at 007 * 008 * http://www.apache.org/licenses/LICENSE-2.0 009 * 010 * Unless required by applicable law or agreed to in writing, software 011 * distributed under the License is distributed on an "AS IS" BASIS, 012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013 * See the License for the specific language governing permissions and 014 * limitations under the License. 015 */ 016 017 package com.google.common.util.concurrent; 018 019 import com.google.common.annotations.Beta; 020 021 import java.util.concurrent.Callable; 022 import java.util.concurrent.TimeUnit; 023 024 /** 025 * Produces proxies that impose a time limit on method 026 * calls to the proxied object. For example, to return the value of 027 * {@code target.someMethod()}, but substitute {@code DEFAULT_VALUE} if this 028 * method call takes over 50 ms, you can use this code: 029 * <pre> 030 * TimeLimiter limiter = . . .; 031 * TargetType proxy = limiter.newProxy( 032 * target, TargetType.class, 50, TimeUnit.MILLISECONDS); 033 * try { 034 * return proxy.someMethod(); 035 * } catch (UncheckedTimeoutException e) { 036 * return DEFAULT_VALUE; 037 * } 038 * </pre> 039 * Please see {@code SimpleTimeLimiterTest} for more usage examples. 040 * 041 * @author Kevin Bourrillion 042 * @since 1 043 */ 044 @Beta 045 public interface TimeLimiter { 046 047 /** 048 * Returns an instance of {@code interfaceType} that delegates all method 049 * calls to the {@code target} object, enforcing the specified time limit on 050 * each call. This time-limited delegation is also performed for calls to 051 * {@link Object#equals}, {@link Object#hashCode}, and 052 * {@link Object#toString}. 053 * <p> 054 * If the target method call finishes before the limit is reached, the return 055 * value or exception is propagated to the caller exactly as-is. If, on the 056 * other hand, the time limit is reached, the proxy will attempt to abort the 057 * call to the target, and will throw an {@link UncheckedTimeoutException} to 058 * the caller. 059 * <p> 060 * It is important to note that the primary purpose of the proxy object is to 061 * return control to the caller when the timeout elapses; aborting the target 062 * method call is of secondary concern. The particular nature and strength 063 * of the guarantees made by the proxy is implementation-dependent. However, 064 * it is important that each of the methods on the target object behaves 065 * appropriately when its thread is interrupted. 066 * 067 * @param target the object to proxy 068 * @param interfaceType the interface you wish the returned proxy to 069 * implement 070 * @param timeoutDuration with timeoutUnit, the maximum length of time that 071 * callers are willing to wait on each method call to the proxy 072 * @param timeoutUnit with timeoutDuration, the maximum length of time that 073 * callers are willing to wait on each method call to the proxy 074 * @return a time-limiting proxy 075 * @throws IllegalArgumentException if {@code interfaceType} is a regular 076 * class, enum, or annotation type, rather than an interface 077 */ 078 <T> T newProxy(T target, Class<T> interfaceType, 079 long timeoutDuration, TimeUnit timeoutUnit); 080 081 /** 082 * Invokes a specified Callable, timing out after the specified time limit. 083 * If the target method call finished before the limit is reached, the return 084 * value or exception is propagated to the caller exactly as-is. If, on the 085 * other hand, the time limit is reached, we attempt to abort the call to the 086 * target, and throw an {@link UncheckedTimeoutException} to the caller. 087 * <p> 088 * <b>Warning:</b> The future of this method is in doubt. It may be nuked, or 089 * changed significantly. 090 * 091 * @param callable the Callable to execute 092 * @param timeoutDuration with timeoutUnit, the maximum length of time to wait 093 * @param timeoutUnit with timeoutDuration, the maximum length of time to wait 094 * @param interruptible whether to respond to thread interruption by aborting 095 * the operation and throwing InterruptedException; if false, the 096 * operation is allowed to complete or time out, and the current thread's 097 * interrupt status is re-asserted. 098 * @return the result returned by the Callable 099 * @throws InterruptedException if {@code interruptible} is true and our 100 * thread is interrupted during execution 101 * @throws UncheckedTimeoutException if the time limit is reached 102 * @throws Exception 103 */ 104 <T> T callWithTimeout(Callable<T> callable, long timeoutDuration, 105 TimeUnit timeoutUnit, boolean interruptible) throws Exception; 106 }


BlockSpring test
matric:
Get profile
Get all students
Matric No:
Job_ID:
Date:
Day:
Time in:
Time out:
Insert into database
#
Name
Matric No
Mobile phone
Job ID


Ben Foden reveals he wanted to ‘do his kids proud’ on X Factor: Celebrity
"Something that's always on my mind is my kids"
by Sarah MaglioccoBen Foden opened up about his family life on last night’s episode of X Factor: Celebrity.
His band Try Star performed The Greatest Show from musical The Greatest Showman, and ahead of the performance, Ben revealed that he hopes he makes his children proud.
Ben shares his daughter Aoife, seven, and son Tadhg, four, with ex-wife Una Healy.
“Something that’s always on my mind is my kids,” he said.
“Obviously I’m doing a song that they love and they’re going to be in the audience watching, they watch every week.”
“They love watching the boys and me on stage so hopefully we can really put on a performance that gets them excited and hopefully Dad will do them proud,” he added.
Ben’s act was eliminated from the competition last night.
However, they received glowing critiques from the judges, who commended them for their powerful performance.
Ben also opened up about his relationship with ex Una earlier this week.
He told MailOnline that he and Una have a “good relationship” for their kid’s sake.
“Una and I have a good relationship for the sake of the kids,” he said.
“I always wish her the very very best. And the kids are loving The X Factor.”


| Mon | Tue | Wed | Thu | Fri | Sat | Sun |
| Mon | Tue | Wed | Thu | Fri | Sat | Sun |
|
|
|
|
|
|
|
|
| 12 AM |
| 1 AM |
| 2 AM |
| 3 AM |
| 4 AM |
| 5 AM |
| 6 AM |
| 7 AM |
| 8 AM |
| 9 AM |
| 10 AM |
| 11 AM |
| 12 PM |
| 1 PM |
| 2 PM |
| 3 PM |
| 4 PM |
| 5 PM |
| 6 PM |
| 7 PM |
| 8 PM |
| 9 PM |
| 10 PM |
| 11 PM |
| 12 AM |


Animation
Support for animation based on dynamic CSG processing is not one of my design goals. I always anticipated severe performance hits due to matching all the surfaces in one shape against all the surfaces in some other set of shapes. I expected to use CSG as a loading operation, absorbing the performance cost as part of initial setup. If animation was desired, I assumed that some N number of frames would be pre-built.
But it is still a fun test to see just what CSG can do dynamically. A rather simple test case is to have two shapes with a common center rotating in opposite directions. Then display the intersection of the two. With simple boxes (12 triangles per box), you get pretty good response. Change one of those boxes to a somewhat smooth cylinder, and the frame rate takes a hit. You can interrogate the blended shape after regeneration to get a count of nanoseconds required to build the shape.
The setup is straight forward. Create two shapes and blend them into a third. In the
update loop, apply rotation to the two primitives, and then regenerate the blended shape.
The CSG code will rebuild the blend from scratch on every regenerate call.
download movie (which is rather choppy due
to the recording being active, but which is rather smooth in real life)
Progressive Rebuild
A more practical form of semi-automation is applying progressive changes to a single target shape. These changes could be triggered by user action, or could be continuous, moving at whatever rate the underlying hardware can provide. CSG is structured to allow you to easily implement progressive changes. The key is that the return of the .regenerate() call is a CSGShape. This shape is the single result of the prior blend, and is ready for use.
A typical design pattern is to save the result of the initial .regenerate() in a 'priorResult' variable. The update action is to first remove all shapes from your target, blend in the priorResult, blend in any new changes, and then save the result of this new .regenerate() back into priorResult. This update loop can be run repetitively, incorporating whatever new changes are desired in each loop.
For example, CSGTestM starts with a cubic block of 'cheese'. The update loop is to
randomly move a spherical 'mouse' within a single quadrant of the block, and then subtract
the sphere from the cube. The result becomes the next starting point, so as the loop
continues, more and more cheese is gnawed away by the mouse. While not smooth enough
for true animation, it is still an effective display.
download movie
Multi-threading
To better support animation and progressive rebuild, the CSG construction process has been made thread aware. Regeneration has been broken into two distinct steps. The first includes all the heavy lifting of analyzing the blending shapes, resolving conflicts, and deciding on the structure of the final result. The second step is applying the final shape to the active visual scene.
By default, .regenerate() executes both steps. But you can use:
which subsequently causes regenerate to execute only the first step. The changes are held internally
within the spatial until explicitly applied by:
myCSGSpatial.deferSceneChanges( true );
which updates the underlying scene. .regenerate() and .applySceneChanges()
are thread-aware and properly synchronized. This means you can drive regeneration (the
CPU intensive step) from a background thread, and call .applySceneChanges() from
within the standard jme3 .update() thread. .applySceneChanges() returns
true if work was done, false if no updates were applied.
myCSGSpatial.applySceneChanges();
As part of being thread-aware, the major internal processing loops monitor Thread.interrupted(). If such an interruption is detected, the regeneration process is aborted and a CSGConstructionException is thrown.
NOTE that CSGConstructionException is a RuntimeException, so that the caller is NOT required to explicitly code in exception handling. java.lang.InterruptedException is not used by the CSG process.


While the Trump administration’s policy change has decreased refugee admissions across nationalities, the change in policy has disproportionately impacted refugees from Muslim-majority nations. Refugees from Muslim-majority nations made up 47% of total refugees resettled in the United States in 2016. In 2018 that share had fallen to just 9%.
These changes to the refugee acceptance policies have had varying impacts across the country. Michigan, for example, went from receiving 3,042 refugees from Muslim-majority nations (71% of total) to just 86 in 2018 (13% of total). In Texas, the number fell from 3,578 in 2016 (46% of total) to just 149 (9% of total). In 2016, 75% of states had at least a third of their refugees coming from Muslim-majority nations. By 2018, no state had at least a third of their refugees coming from a Muslim-majority nation, with 8 states and DC receiving no refugees from Muslim-majority nations at all. Even if a state wants to admit more refugees they have little recourse for influencing the number of refugees resettled in their jurisdiction.
| Muslim-Majority | |
| Non-Muslim-Majority |
Once a refugee is admitted into the United States, they are matched with a nonprofit Volunteer Resettlement Agency (VOLAG)
who is tasked with providing sponsorship, initial housing, food, clothing, orientation, and counseling. These organizations are scattered
across the country and rely primarily on federal funding to support their activities. The decrease in refugees admissions has already resulted
in the closure of dozens of VOLAG offices across the country,
with the government submitting a plan to close nearly a quarter of the offices, eliminating offices in Hawaii, West Virginia, and Louisiana all together.
Misinformation has driven many negative conceptions about refugees, particularly those coming from Muslim-majority nations.
However, emerging research is disproving these myths. A recent report from Stanford University’s Immigration Policy Lab indicates that reducing
the number of refugees in a community does not reduce the crime rate. Research from the Center for American Progress find that refugees quickly become
self-sufficient and, in the long-run, become well-integrated into society, having similar rates of labor force participation, wages and business ownership
as their U.S. born neighbors. Rather than being a financial burden to the U.S., research found that between 2005 and 2013 refugees and asylees contributed $63 billion
more in taxes than they utilized in public services.
One of the first policy decisions made by the Trump administration was to halt refugee settlement in the United States. On January 27, 2017, President Trump signed Executive Order 13769, commonly known as the Muslim Ban, which barred entry from seven Muslim-majority nations and
imposed a 120-day ban on all refugees entering the United States. While the courts intervened to dismantle portions of the ban, in October, 2017 the administration passed new vetting policies that further slowed resettlement processes and imposed a new 90-day ban on 11 countries, including nine Muslim-Majority countries.
These federal actions resulted in a dramatic slowdown in domestic refugee resettlement. Despite the 110,000 ceiling in 2017, the United States only resettled 53,716 refugees. In 2018, the Trump administration further reduced the cap to a nearly 40-year low of 45,000, and, over the course of the year, resettled less
than half of that target (22,491). In 2019, the Trump Administration announced it would further reduce the cap to 30,000 refugees and, as of May 2019, the country is well short of reaching that limit.
These reductions in United States refugee resettlement are coming at a time when the number of refugees worldwide is growing. According to the UN High Commissioner for Refugees (UNCHR), the number of refugees globally nearly doubled between 2012 and 2017, from 10.4 million to 19.9 million over the five years. As a result the United States is further exacerbating the global refugee crisis.


The <tc:selectManyList/> component has a filter attribute with four predefined values:
contains, startsWith, containsExact, startsWithExact
Choose between different filter types.
Dependent of the type of the filter:
Ignores case.
Ignores acute (é), grave (è), circumflex (â, î or ô), tilde (ñ), umlaut and
dieresis (ü or ï), and cedilla (ç).


Mobile Applications
Presently, iOS and Android technologies are dominating mobile platforms. The competition between the two technologies have resulted in innovations that were beyond one’s imagination just a few years ago. This healthy competition has resulted in invention of some amazing applications, be it apps for social interaction, gaming & utility, hyperlocal targeting apps and many more.
Web Development
A web application is a conventional option, however, it has its own advantages like more play space, clutter-free UI, powerful computational capabilities - areas where the mobile platform is yet to catch up. A powerful web application coupled with strong backend is quintessential for every business.


ACAC
Home
About
Contact
Author name
Article title
Subject
News
Feature
Narrative
Expository
Content
day:
month:
Year:


Soccer
{% if likes_same_sport==False %}
Soccer is the best sport because it teaches teamwork and it's fun
{%else%}
My Best Players:
{%for i in player_list %}
{{i}}
{% endfor %}
{%endif%}