| Description | Example: | Creates: |
| Text surrounded by asterisks or underscores will be made italic | *italics* | italics |
| Text surrounded by double asterisks will be bold | **bold** | bold |
| To create a hyperlink, surround the text you want to be the link with brackets followed by the URL in parenthesis. | linked text | |
| A line of text starting with a pound symbol will become a heading. There are six levels of heading which you can reach by adding more pound signs. | #heading 1 |
|
| ##heading 2 | heading 2 |
|
| You can also create a header by following it with two or more equal signs or hyphens. | heading 1 =========== |
|
| heading 2 ----------- |
heading 2 |
|
| A series of lines beginning with hyphens will create an unordered list. |
- item 1 - item 2 - item 3 |
|
| A series of lines beginning with numbers followed by a period will create an ordered list. |
1. item 1 2. item 2 3. item 3 |
|
| A line started with a greater-then symbol will identify that text as being quoted from someone else. | > quoted text | quoted text |
| Lines starting with four spaces are treated as preformatted text and will display without wrapping. |
if 1 * 2 < 3: print "hello, world!" |
if 1 * 2 < 3: |


Legacies Promises a 'Surprisingly Violent' Christmas Episode
by Sundi RoseLegacies -- The CW's latest contribution to The Vampire Diaries franchise -- is promising viewers a good bit of holiday violence in the title of the upcoming Christmas episode. While viewers can usually expect a fair amount of blood and gore from these vampire shows, when the show, itself, promises some "surprising" violence, then fans know they are in for a shock.
The promise comes straight from a newly released synopsis that reveals the title of the Dec. 12 episode, "This Christmas Was Surprisingly Violent." In addition its titled, The CW reveals the holiday episode will feature a Christmas monster that uses holiday spirit to infiltrate the Salvatore School. Also, Landon offers some surprise news about his family to Rafael. Meanwhile, Sebastian teams up with Lizzie for her latest mission.
Click the button below to start this article in quick view.
Per the full synopsis for "This Christmas Was Surprisingly Violent,"
IT’S CHRISTMAS IN MYSTIC FALLS — Hope (Danielle Rose Russell) joins forces with an unlikely ally to take down a Christmas monster, who’s using holiday cheer to infiltrate the Salvatore School. Elsewhere, Landon (Aria Shahghasemi) surprises Rafael (Peyton Alex Smith) with news about his family lineage, and Sebastian (guest star Thomas Doherty) accompanies Lizzie (Jenny Boyd) on her latest mission. Kaylee Bryant and Matthew Davis also star. Brett Matthews directed the episode written by Brett Matthews & Hannah Rosner (#208). Original airdate 12/12/2019.
Airing Thursdays at 9 pm ET on The CW, Legacies stars Danielle Rose Russell as Hope Mikaelson, Jenny Boyd as Lizzie Saltzman, Kaylee Bryant as Josie Saltzman, Quincy Fouse as Milton Greasley/MG, Aria Shahghasemi as Landon Kirby, Peyton Alex Smith as Rafael Waithe and Matt Davis as Alaric Saltzman.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2TVhttps://www.cbr.com/category/tv/ListItem3TV Newshttps://www.cbr.com/category/tv/news-tv/ListItem4Legacies Promises a 'Surprisingly Violent' Christmas Episodehttps://www.cbr.com/legacies-surprisingly-violent-christmas-synopsis/


Class: Qo::Branches::Branch
- Inherits:
-
Object
- Object
- Qo::Branches::Branch
- Defined in:
- lib/qo/branches/branch.rb
Overview
Branches
A branch is a particular branch of a pattern match. The default branches
emulate a case
statement. Consider a case
statement like this:
case value
when condition then first_return
else second_return
end
With a Qo branch you would see something like this:
Qo.match { |m|
m.when(condition) { first_return }
m.else { second_return }
}
The when
and else
are the names the branch was "registered" with in
Qo::PatternMatchers::Branching
. The name becomes the method name that
the associated matcher uses.
Order of Execution
A branch will execute in the following order:
value -> precondition ? -> extractor -> condition ? -> destructurer
Preconditions allow for things like type checks or any static condition that will remain constant across all matches. Think of them as abstracting a single condition to guard before the branch continues.
Conditions are typical Qo matchers, as documented in the README. Upon a match, the branch will be considered matched and continue on to calling the associated block function.
Extractors are used to pull a value out of a container type, such as
value
for monadic types or last
for response array tuples.
Lastly, if given, Destructurers will destructure an object. That means that the associated function now places great significance on the names of the arguments as they'll be used to extract values from the object that would have normally been returned.
Destructuring can be a complicated topic, see the following article to find out more on how this works or see the README for examples:
https://medium.com/rubyinside/destructuring-in-ruby-9e9bd2be0360
Match Tuples
Branches will respond with a tuple of (status, value). A status of false
indicates a non-match, and a status or true indicates a match. This is done
to ensure that truly false
or nil
returns are not swallowed by a
match.
A Pattern Match will use these statuses to find the first matching branch.
Direct Known Subclasses
ElseBranch, ErrorBranch, FailureBranch, MonadicElseBranch, MonadicWhenBranch, SuccessBranch, WhenBranch
Constant Summary
- UNMATCHED =
Representation of an unmatched value. These values are wrapped in array tuples to preserve legitimate
false
andnil
values by indicating the status of the match in the first position and the returned value in the second. [false, nil]
Instance Attribute Summary collapse
-
#name ⇒ Object
readonly
Name of the branch, see the initializer for more information.
Class Method Summary collapse
-
.create(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) ⇒ Class
A dynamic creator for new branch types to be made on the fly in programs.
Instance Method Summary collapse
-
#create_matcher(conditions, destructure: @destructure, &function) ⇒ Proc[Any]
Uses the current configuration of the branch to create a matcher to be used in a pattern match.
-
#default? ⇒ Boolean
Whether or not this is a default branch.
-
#initialize(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) ⇒ Qo::Branches::Branch
constructor
Creates an instance of a Branch.
Constructor Details
#initialize(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) ⇒ Qo::Branches::Branch
Creates an instance of a Branch
113 114 115 116 117 118 119 |
# File 'lib/qo/branches/branch.rb', line 113 def initialize(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) @name = name @precondition = precondition.is_a?(Symbol) ? precondition.to_proc : precondition @extractor = extractor.is_a?(Symbol) ? extractor.to_proc : extractor @destructure = destructure @default = default end |
Instance Attribute Details
#name ⇒ Object (readonly)
Name of the branch, see the initializer for more information
76 77 78 |
# File 'lib/qo/branches/branch.rb', line 76 def name @name end |
Class Method Details
.create(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) ⇒ Class
A dynamic creator for new branch types to be made on the fly in programs. This exists to make new types of pattern matches to suit your own needs.
Prefer the public API to using this method directly, Qo.create_branch
,
mostly because it's less typing.
131 132 133 134 135 136 137 138 139 140 141 142 143 |
# File 'lib/qo/branches/branch.rb', line 131 def self.create(name:, precondition: Any, extractor: IDENTITY, destructure: false, default: false) attributes = { name: name, precondition: precondition, extractor: extractor, destructure: destructure, default: default } Class.new(Qo::Branches::Branch) do define_method(:initialize) { super(**attributes) } end end |
Instance Method Details
#create_matcher(conditions, destructure: @destructure, &function) ⇒ Proc[Any]
Uses the current configuration of the branch to create a matcher to
be used in a pattern match. The returned proc can be passed a value
that will return back a tuple of (status, value)
to indicate whether
or not a match was made with this branch.
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 |
# File 'lib/qo/branches/branch.rb', line 169 def create_matcher(conditions, destructure: @destructure, &function) function ||= IDENTITY destructurer = Destructurers::Destructurer.new( destructure: destructure, &function ) Proc.new { |value| # If it's a default branch, return true, as conditions are redundant if @default extracted_value = @extractor.call(value) next [true, destructurer.call(extracted_value)] end # Otherwise we check the precondition first before extracting the # value from whatever container it might be in. next UNMATCHED unless @precondition === value extracted_value = @extractor.call(value) # If that extracted value matches our conditions, destructure the value # and return it, or return unmatched otherwise. conditions === extracted_value ? [true, destructurer.call(extracted_value)] : UNMATCHED } end |
#default? ⇒ Boolean
Whether or not this is a default branch
148 149 150 |
# File 'lib/qo/branches/branch.rb', line 148 def default? @default end |


About
Who we are
Welcome mentors and mentees.Let's get you started.
- We are the proud students of technology, here to help build your future.
- We offer FREE matchmaking services, that will connect mentors and mentees.
- We are all about the perfect fit! Rest assured, we find mentors who are perfect for you.
"Here to help.Here to connect.Here to assist"
This is our motto, and we swear by it.We as a team believe that every curious mind deserves a chance to explore that curiosity without being shackled to competition and comparision. Our service provides the perfect oppotunity for such tender-curiosity filled minds to find the perfect partner in crime, who will help them explore the stranger things of the world.
Call To Action
The ongoing COVID-19 crisis brought the entire world to a stand-still.This not only hindered sports,cinema and business, but also left a huge dent in the education sector.The world of education was not equipped to handle a sudden transition to the online mode.In a country like ours, many children in the remote, rural villages found it next to impossible to continue their schooling during the past two years.And thus came along MENTOR AND MENTEE ready to help anyone who wants to learn.
Services
HOW TO USE THIS SITE?
STEP 1 : Create an account
All you have to do to join our family, is just to create and account.
Click on the "Creat Account" option on the top part of the website,and create your account as mentor or mentees.
We appreciate your patience.We promise to not bug you with hundreds of e-mails,so please don't hesitate.
STEP 2 : Create your profile
Once you have logged into you account,fill up all the details without hesitation or fear.We strongly believe in privacy of our users.Rest assured, your information is in safe hands!
STEP 3: The easy part
Once you have filled your profile with honest and real information, just press the "Find Me A Mentor/Mentee" button on the bottom of the page.Now all you have to do is sit back,relax,maybe even sip on some coconut water and let our algorithm do the rest.We will alert you once we find you a perfect match!
Testimonials
What they are saying about us
F.A.Q
Frequently Asked Questions
-
How can I find A mentor ?
All you have to do is follow the three steps mentioned in "How to use this site".This will get you a mentor.
-
How will you get me a mentor ?
We use artificial intelligence technology to find you a mentor, completely based on your profile.Hence we strongly advice you to be as honest as possible while creating your profile.
-
Do I have to pay for this website and the mentor I get ?
No,we do not charge you any money to use this website and the mentor assigned to you.This is a completely free service intended to help the students who do not have access to such resources.
-
Can this website sell my personal information ?
We strongly believe in privacy.Hence we do not use your personal information for any other purpose other than to find you a mentor.
Team
Our Hardworking Team
Prajwal
Samanvitha Rao
Deeksha
Varun Kumar
Contact
Contact Us
Location:
PES UNIVERSITY
Email:
<EMAIL_ADDRESS>Call:
+91<PHONE_NUMBER>


We are coming soon
Tell the users that your website is not active yet. Put the reason to subscribe for the notification in this paragraph. Tell them about their problems which you would like to solve. Don’t forget the final call to action.
2015 - TheDevKnights
TheDevKnights | Page and Design by M. Aghili + Ilya B.


DNS bits and pieces
This is a collection of various bits of open source C code that implement parts of the DNS protocol (rfc 1035), SRV records, Multicast
DNS, and Service Discovery (aka dns-sd, or Apple's Rendezvous). Unless otherwise noted in the file,
the license is GPL, jabber me at<EMAIL_ADDRESS>to request any other licensing terms if needed.
- tinysrv.c
- A very basic/rudimentary SRV/A resolver with no dependencies (on libresolv, libc, anything, straight C).
Mostly for educational use.
- demosrv.c
- Uses tinysrv.c as a command line resolver, testing tool.
- socket.c
- Few basic TCP/UDP socket routines, used by demosrv.c.
- 1035.c/1035.h
- A very minimal implementation of RFC 1035 Messages, both
parsing/decoding and generation. Creates a simple struct and is
entirely self-contained. Handles en/decoding numerous RR data types
(A, PTR, CNAME, SRV, etc) as well.
- ichat.c/ichat.h
- Some utility functions to process/create Apple's iChat TXT
data (soon to be depreciated in favour of normal DNS-SD TXT
records).
- mcast.c
- A bunch of notes and code bits on dealing w/ multicast and
particularly system interfaces, a mess to say the least.


[gecode-users] Stability of a solution
Christian Schulte
cschulte at kth.se
Wed Oct 16 08:49:58 CEST 2013
Hi Philippe,
I assume from what you write that you the variables of your problem(s) stay the same while the constraints change. Is tthat correct?
Then, what you can do is to take a space for the new problem (with the new constraints) and assign the variables in the new problem to the values of the old problem. If the space fails, the old solution is not any longer valid. The cost can be accessed as always...
Hope that helps
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf Of Philippe
Sent: Wednesday, October 16, 2013 12:09 AM
To: users at gecode.org
Subject: [gecode-users] Stability of a solution
Hi all,
I have a constraint satisfaction problem correctly solved by gecode using a Branch & Bound engine. However, I have a stability issue :
This problem should be solved frequently with minor changes and I get a different solution each time I solve it (I solve it from scratch every 3 s and the search is time constrained to 10 ms)
Thus, to have a stable solution, I have to know if the previous solution is still valid and I have to compare its cost (relatively the updated problem) to the best new solution. Unfortunately, this previous solution is not always analyzed (even if this solution is probably still relevant) since I am time constrained.
Is there an elegant way to check if the previous solution is still valid and to compute its cost?
Thanks for tips,
Cheers,
Philippe
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


%= require('html-loader!./common/head.html') %>
Bitcoinalert.io is here to make sure that you will not miss the golden chance you are longing for as the market swings at any time of the day. Crypto prices are subject to a number of factors and you will need to focus on your price charts each day to watch the changes. Knowing that the price watch can be time-intensive, we have dedicated our time, staff, and technology to comb the markets.
Price movements and volatility provides the crypto trader with openings to ride the market and make some gains. At bitcoinalert.io, we empower our readers with the needed stats to buy, sell and trade cryptocurrencies.
Most traders have to continually star the price charts to keep with price changes and determine at what rate to buy. By using our alert system, you are notified when the preferred price for you crypto is reached, and you can simply go ahead to buy or sell as you desire.
We ensure that we keep our eyes on the more than 1,000 tokens and coins that are available for daily trade each day. We do the heavy lifting on your behalf so that you have the defining data you need each day for crypto trades.
Contact us: support( AT )bitcoinalert.io


Welcome to C2DPlugin Project Wizard
This wizard helps students to create a Calculation2D plugin...
Student information
Calculation method
N
ame:
S
urname:
e
-mail:
G
roup:
P
art:
-------------------
all
I
II
III
IV
F
inish
C
ancel
H
elp


30% + 10% additional off site-wide till Oct 15th Enroll now
Artificial Intelligence is a field of study which enable computers to think. Machine Learning and Deep Learning helps us in achieving this. In order to understand the complete end to end life cycle of an AI project, one should be able to explore the data, make inferences from the data, perform feature engineering and build models, evaluate those models and deploy the complete project as a software
Mathematical Essentials, Exploratory Data Analysis, Machine Learning and Deep Learning etc
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Voluptate incidunt dicta voluptates reiciendis asperiores ullam, impedit ab animi exercitationem reprehenderit perspiciatis ducimus atque minima veniam. Perferendis, nulla. Rerum, sequi accusamus. Odit cumque laborum asperiores ex placeat fugit iure aliquid aperiam quibusdam aspernatur? Veritatis, aliquid itaque. Qui voluptatem esse aut? Rem non quos ea quae magnam soluta facere vero provident dolore!
Python, Data Analytics, Data Science, R Programming, Machine Learning, Deep Learning, Image Processing, Computer Vision, Java, GCP, Git
AI research and Software Development
Lorem ipsum dolor sit amet consectetur adipisicing elit. Doloremque ex molestiae vero perspiciatis? Itaque, est modi voluptates excepturi molestiae dignissimos.
Lorem ipsum dolor sit amet consectetur adipisicing elit. Ab odit officiis saepe. Aliquid, beatae necessitatibus.
1. GIT (Version Control, Collaboration)
2. Python Programming (Setting up the environment, Data types and
data structures, Decision Statements – if else, Conditional
Statements – while and for loop, Functions and Modules)
a) Get comfortable with Github. You’ll most likely be storing all
of your code in Github. Once you are working, you’ll be using Git
anyway to coordinate with other developers, so might as well start
now.
b) Python is one of the most popular programming languages used by
developers today. Guido Van Rossum created it in 1989 and ever
since it’s been one of the most liked programming languages along
with C++ and Java.
c) Python along with packages like NumPy, scikit-learn, pandas,
and matplotlib form the basis to start your AI project.
1. Linear Algebra (Matrices and Vector Algebra, Dot Product, Projection) 2. Statistics (Mean, Median, Mode, Variance, Standard Deviation and Correlation, Percentiles) 3. Probability (Axioms of Probability, Conditional Probability, Random Variables)
a) Statistics is a collection of tools that you can use to get answers to important questions about the data b) Probability is the study of uncertainty. It deals with predicting the likelihood of future events. Probability is undeniably a pillar of the field of machine learning. Why so? Machine learning is about developing predictive models from uncertain data and perform predictions on future unseen data c) Last but not least. Linear Algebra — Daily bread and butter for Machine Learning. Without this you can’t develop machine learning methods. It allows us to operate in higher dimensional space
1. Data Analysis (Numpy and Pandas) 2. Data Visualization (Matplotlib, Seaborn and Plotly) 3. Telling Story about Data (Univariate, Bivariate and Multivariate
a) NumPy is used as one of the most powerful numerical processing library in python which provides extension package for multi-dimensional array computation. b) Another useful library is pandas, which can be used to load the data in memory and perform analytics on top of it. c) If data is humongous, we might miss on some of the very insightful patterns. This is where visualization libraries like Matplotlib, Seaborn and Plotly comes for rescue.
1. Data Preparation and Feature Transformation (Normalization and Standardization, One Hot Encoding, Label Encoders, Stemming, Lemmatization, Bag of Words, TF-IDF) 2. Regression (Linear Regression, SVR, DT Regression) 3. Classification (Logistic Regression, Decision Tree Classifier, Support Vector Machines, Random Forest) 4. Clustering (K-Means, Principal Component Analysis) 5. Deep Learning (History, Neural Network, ANN, Perceptron’s and Activation Functions)
a) Data preparation (also referred to as “data preprocessing”) is the process of transforming raw data so that data scientists and analysts can run it through machine learning algorithms to uncover insights or make predictions. b) The regression and classification task comes from supervised machine learning. Regression helps in prediction when the target or output variable is a continuous value whereas classification is used when we have a limited set of outcomes. c) An unsupervised learning technique performs as a way of grouping related items together into various clusters. It doesn’t have any output information for the training process.
1. Web Application Development (Project implementation using some framework) 2. Deployment(Process, prepare, deploy client, deploy server)
a) Throughout the course we will be building several projects. By the end of the course, you will be able to understand the end-to-end lifecycle of a ML project. Your skill will also include deploying your projects on the internet.


Visit our site at http://www.entertainmentcruises.com
HAPPY SPRING BREAK FROM YOUR FRIENDS AT THE PIER.
Looking for something to do over break? Come out to Navy Pier and
enjoy some time off with your friends and family aboard one of our
unique ships. There’s no better way to relax and take in the sights
this spring.
Check out our current cruise schedules here
(http://www.entertainmentcruises.com/city/Chicago/home).


H1 text
DIV 1
CLASS 1
A link
Unicode character Ñ
Test popup
This is some arbitrary text to check for verifyTexts


For the environment passed into the launch
callback, configNameRegex
has been renamed to configNameSearch
. It now returns an array of valid config names instead of a regular expression.
The method signature for launch
was changed in this version of Liftoff.
You must now provide your own options parser and pass your desired params directly into launch
as the first argument. The second argument is now the invocation callback that starts your application.
To replicate the default functionality of 0.10, use the following:
js
const Liftoff = require('liftoff');
const MyApp = new Liftoff({name:'myapp'});
const argv = require('minimist')(process.argv.slice(2));
const invoke = function (env) {
console.log('my environment is:', env);
console.log('my cli options are:', argv);
console.log('my liftoff config is:', this);
};
MyApp.launch({
cwd: argv.cwd,
configPath: argv.myappfile,
require: argv.require,
completion: argv.completion
}, invoke);


Bayelsa: PDP Deputy Governorship Candidate Cast Vote
by George OgboluThe Deputy Governorship candidate of the Peoples Democratic Party (PDP), Senator Lawrence Erujakpo, has cast his vote in the Bayelsa Guber election.
Naija News reports that Ofoni community is the home town of Erujakpo.
Recall that the Governorship candidate of the PDP, Duoye Diri, is yet to cast his vote.
There are eight polling units in his Sampou/Kalama ward 6. But neither materials for the poll or the INEC officials have arrived.


“No problem can be solved from the same level of consciousness that created it.”
— Albert Einstein
I first started programming as a student at DevMountain to "get skills and pay bills." After learning more and more about programming and understanding what happens behind-the-scenes, I discovered a deep seated passion for solving complex logic puzzles.
Since then I have continuosly strived to learn more wherever I can and to practice creating new and exciting functionality to original code.
React
JavaScript
Node
Express
Sql
Git
Angular
HTML5
CSS3
Bootstrap
Sass
Gulp
While I was a student at DevMountain, I built this full stack Pixel Eyewear Clone to expand my understanding of several different development processes.
My main focus was further exploring HTTP request methods, MVC frameworks, and flat lay web design.
This project was built using:
HTML5, SCSS and Bootstrap Design, Angular framework, NodeJS, ExpressJS, MassiveJS, Heroku Database, Sql, Gulp
Due to copyright restrictions this website cannot be hosted, for a full demo please visit the link below.
Video Walkthrough
For our group project, we decided that we wanted to learn and build in React.
Our main concept was focused on being able to visually display data in sets of tables and charts.
We accomplished this by creating a simple web app designed to give an executive or CEO a quick oversight of certain aspects of their business.
This project was built using:
ReactJS, Redux, ChartsJS, MassiveJS, Sql, Heroku Database and Git
Video Walkthrough
This project is a nonfunctional home page website for a fictional business built to further explore what is available
in HTML5 and CSS3.
This project was built using:
HTML5, CSS3 and jQuery
View Website | Video Walkthrough


[gecode-users] ~Event nothrow issue
Christian Schulte
cschulte at kth.se
Mon Aug 17 16:08:54 CEST 2015
Hi Filip,
Thanks! I also recently installed MSVC 2015 and hence have already fixed the
issue in the trunk.
Cheers
Christian
--
Christian Schulte, www.gecode.org/~schulte
Professor of Computer Science, KTH, cschulte at kth.se
Expert Researcher, SICS, cschulte at sics.se
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Filip Konvicka
Sent: Monday, August 17, 2015 2:49 PM
To: users at gecode.org
Subject: [gecode-users] ~Event nothrow issue
Hi,
I've tried compiling Gecode 4.4.0 with MSVC 2015 and it produces warnings
about ~Event being (implicitly) nothrow but throwing exceptions at the same
time.
I was thinking whether or not it is worth fixing in Gecode code, and found
this nice explanation:
http://denisbider.blogspot.cz/2015/07/exceptions-in-destructors-and-visual.h
tml
I believe either noexcept(false) (portable but probably C++11 only
syntax) or throw(...) might help - possibly replacing "..." with something
reasonable.
Cheers,
Filip
_______________________________________________
Gecode users mailing list
users at gecode.org
https://www.gecode.org/mailman/listinfo/gecode-users
More information about the users
mailing list


Trump's America : The Truth about Our Nation's Great Comeback
by Newt Gingrich
Overview -
No one understands the Make America Great Again effort with more insight and more experience than former
Speaker of the House Newt Gingrich. Gingrich helped President Ronald Reagan “Make America Great Again” in 1980. He authored
the Contract with America and spearheaded the 1994 Republican Revolution that brought the House of Representatives under Republican
control after 40 years. He knows what it is like to fight the Washington swamp and challenge the establishment – he has done it his
entire career. Now, the author of the #1 New York Times best seller Understanding Trump is back to illustrate how our nation’s
45th President is leading our country’s great comeback. From the fight of over the Southern Border Wall, to the Republican tax
cuts, to the swamp’s unending efforts to undermine and oppose the President, Trump’s America lays out the truth about the Trump
presidency – the truth the mainstream media won’t tell you. In this book, Gingrich — who has been called the President’s chief
explainer – presents a clear picture of this historic presidency and the tremendous, positive impact it is having on our nation and
the world. Gingrich unmasks the various branches of the anti-Trump coalition that are trying to stop America’s great comeback.
He reveals the flaws in their ideological assaults on the President and offers a battle plan for those in Trump’s America to help
the President defeat these attacks. Throughout Trump’s America, Gingrich distills decades of experience fighting Washington with
a lifetime of studying history to help every American understand how we can all keep working to make America great.


AWS::Redshift::ClusterSecurityGroup
Creates an Amazon Redshift security group. You use security groups to control access to Amazon Redshift clusters that are not in a VPC.
Topics
Syntax
To declare this entity in your AWS CloudFormation template, use the following syntax:
JSON
{ "Type" : "AWS::Redshift::ClusterSecurityGroup", "Properties" : { "Description" :
String
, "Tags" : [Resource Tag, ...
] } }
YAML
Type: "AWS::Redshift::ClusterSecurityGroup" Properties: Description:
String
Tags: -Resource Tag
Properties
Description
-
A description of the security group.
Required: Yes
Type: String
Update requires: Replacement
Tags
-
Specifies an arbitrary set of tags (key–value pairs) to associate with this security group. Use tags to manage your resources.
Required: No
Type: Resource Tag
Update requires: No interruption
Return Values
Ref
When the logical ID of this resource is provided to the Ref
intrinsic
function, Ref
returns the resource name. For example:
{ "Ref": "
myClusterSecurityGroup
" }
For the Amazon Redshift cluster security group myClusterSecurityGroup
,
Ref
returns the name of the cluster security group.
For more information about using the Ref
function, see Ref.
Example
The following example creates an Amazon Redshift cluster security group that you can associate cluster security group ingress rules with:
JSON
"myClusterSecurityGroup": { "Type": "AWS::Redshift::ClusterSecurityGroup", "Properties": { "Description": "Security group to determine where connections to the Amazon Redshift cluster can come from", "Tags": [ { "Key": "foo", "Value": "bar" } ] } }
YAML
myClusterSecurityGroup: Type: "AWS::Redshift::ClusterSecurityGroup" Properties: Description: "Security group to determine where connections to the Amazon Redshift cluster can come from" Tags: - Key: foo Value: bar


Files CCore/inc/Array.h CCore/src/Array.cpp
Subfolders CCore/inc/array CCore/src/array
There are several types, which are used to specify the constructor behavior.
/* words */ enum DoBuildType { DoBuild }; enum DoReserveType { DoReserve };
DoBuild and DoReserve are words. They designate the build and the reserve variant of the constructor respectively.
template <int Sw> class DoSomething { ulen len; ulen maxlen; public: explicit DoSomething(ulen len); // maxlen == len DoSomething(ulen len,ulen maxlen); // maxlen >= len ulen getLen() const { return len; } ulen getMaxLen() const { return maxlen; } }; typedef DoSomething<1> DoRaw; typedef DoSomething<2> DoFill; typedef DoSomething<3> DoCopy; typedef DoSomething<4> DoCast; typedef DoSomething<5> DoSwap; typedef DoSomething<6> DoCreate;
DoRaw, DoFill, DoCopy, DoCast, DoSwap, DoCreate are not words, but Small Data Types. They designate the correspondent variant of constructor and carry two parameters: the array length and the reserved length. When the array is being created, the reserved length determines the memory space to be allocated, and the length is the number of elements to be created. An exception is thrown, if len is greater than maxlen.
Array is a container, where multiple items comprise a continuous range. The simplest such "container" is the embedded type "array of" T[Len]. Unfortunately, this type lacks many abilities, required in applications, so we need a variety of Arrays. We don't use STL vector, because it also has many deficiencies. CCore Arrays use the CCore heap with its extra functionality. They also customizable using an Algorithm Package of array algorithms.
CCore Arrays implement Range Access Interface. They also provide the index access to elements through the overloaded operator [] and the checked index access with the method at().
Constant CCore Arrays give constant access to its elements.
Allocation errors and index check errors throw exceptions. Default constructors are no-throw.
The method apply() applies the functor, given by a Functor Init, to array elements. If the array is constant, then element references are constant too. The variant apply_const() also enforces constantness.
The method applyReverse() applies the functor, given by a Functor Init, to array elements in the reverse order. If the array is constant, then element references are constant too. The variant applyReverse_const() also enforces constantness.
Arrays can be used with most types, there is no hard restrictions on type properties. The only strong requirement is: the type destructor must be no-throw. Some operations, however, require additional type properties. For example, to use cloneTo() methods the type must be copyable.
All CCore Arrays available through the header CCore/inc/Array.h.
TempArray is the simplest of Arrays. It is applicable only to POD types. This container combines stack storage and dynamic storage to speed up the array construction/destruction for a short lengths. Use this Array if you need a temporary buffer with expected short length in the most cases.
template <class T,ulen StackLen>
class TempArray : NoCopy
{
private:
T *ptr;
ulen len;
T buf[StackLen];
public:
// constructors
TempArray();
explicit TempArray(ulen len);
~TempArray();
// methods
void provide(ulen len);
void reset(ulen len);
bool extend(ulen len);
// range access
T * getPtr() { return ptr; }
const T * getPtr() const { return ptr; }
const T * getPtr_const() const { return ptr; }
ulen getLen() const { return len; }
// index access
T & operator [] (ulen index);
const T & operator [] (ulen index) const;
T & at(ulen index);
const T & at(ulen index) const;
// apply
template <class FuncInit>
void apply(FuncInit func_init);
template <class FuncInit>
void apply(FuncInit func_init) const;
template <class FuncInit>
void apply_const(FuncInit func_init) const;
template <class FuncInit>
void applyReverse(FuncInit func_init);
template <class FuncInit>
void applyReverse(FuncInit func_init) const;
template <class FuncInit>
void applyReverse_const(FuncInit func_init) const;
};
If the array length is not greater than StackLen, then TempArray uses the internal buffer. Otherwise, the space for elements is dynamically allocated.
provide() ensures the array has at least the given length, reallocating it if required. The previous array content may be lost. The new content is not initialized.
reset() recreates the array with the given length, reallocating it if required. The previous array content may be lost. The new content is not initialized.
extend() extends the array up to the given length. If len is less or equal than the current array length, the method does nothing and returns false. Otherwise it extends the array, preserving the current content, and returns true. The new content is not initialized. An exception is thrown if there is no memory.
Other methods are standard array methods.
SimpleArray is another "simple array". It is applicable to (almost) any types.
The second template argument of SimpleArray is an Algorithm Package of array algorithms. SimpleArray uses only two of them: Create_default() and Destroy(). See below about array algorithms.
template <class T,class Algo=ArrayAlgo<T> >
class SimpleArray : NoCopy
{
T *ptr;
ulen len;
public:
// constructors
explicit SimpleArray(ulen len=0);
~SimpleArray();
// range access
T * getPtr() { return ptr; }
const T * getPtr() const { return ptr; }
const T * getPtr_const() const { return ptr; }
ulen getLen() const { return len; }
// index access
T & operator [] (ulen index);
const T & operator [] (ulen index) const;
T & at(ulen index);
const T & at(ulen index) const;
// apply
template <class FuncInit>
void apply(FuncInit func_init);
template <class FuncInit>
void apply(FuncInit func_init) const;
template <class FuncInit>
void apply_const(FuncInit func_init) const;
template <class FuncInit>
void applyReverse(FuncInit func_init);
template <class FuncInit>
void applyReverse(FuncInit func_init) const;
template <class FuncInit>
void applyReverse_const(FuncInit func_init) const;
// swap/move objects
void objSwap(SimpleArray<T,Algo> &obj);
explicit SimpleArray(ToMoveCtor<SimpleArray<T,Algo> > obj);
SimpleArray<T,Algo> * objMove(Place<void> place);
};
SimpleArray allocates space dynamically.
Unlike TempArray, SimpleArray is swappable and movable.
DynArray is the "main" of Arrays. It stores elements in a memory space with some reserved memory behind. It can extend the range of elements, if there is an extra memory. If not and the type T supports moving, then the array extension can be performed with either the memory block extension (using MemExtend()) or the total reallocation with the content moving. You can also release the extra memory. All details of the array functionality can be customized using the second template argument, which is an Algorithm Package of array algorithms.
Alone with standard methods, DynArray has a bunch of methods to initialize and control the array content.
template <class T,class Algo=ArrayAlgo<T> >
class DynArray : NoCopy
{
....
public:
// constructors
DynArray();
template <class S>
explicit DynArray(std::initializer_list<S> il);
explicit DynArray(ulen len);
DynArray(ulen len,ulen maxlen);
DynArray(DoReserveType,ulen maxlen);
explicit DynArray(DoRaw dotype);
template <class ... SS>
explicit DynArray(DoFill dotype,SS && ... ss);
DynArray(DoCopy dotype,const T src[]);
template <class S>
DynArray(DoCast dotype,const S src[]);
DynArray(DoSwap dotype,T objs[]);
template <class Creator>
DynArray(DoCreate dotype,Creator creator);
template <class Builder>
DynArray(DoBuildType,Builder builder);
~DynArray();
Non-default constructors reserve some space and build some elements. The DoRaw, ..., DoCreate arguments carry the length and the reserved length of the array to be used.
Non-default constructors work the same way as the correspondent extend...() methods.
DynArray(std::initializer_list<S> il) uses the initialization list to "cast" elements from the given.
DynArray(ulen len) creates the array of the len elements using the default constructor.
DynArray(ulen len,ulen maxlen) also performs the default initialization of the len elements, but reserves a space for the maxlen elements. An exception is thrown, if len is greater than maxlen.
DynArray(DoReserveType,ulen maxlen) just reserves a space.
DynArray(DoRaw dotype) performs the "raw" initialization. If the T is a POD type, elements are not initialized. If not, the default initialization is performed.
DynArray(DoFill dotype,SS && ... ss) creates new elements using some constructor, the specified arguments are forwarded to this constructor.
DynArray(DoCopy dotype,const T src[]) creates new elements using the copy constructor, src is a range of length dotype.getLen(), its members are copied memberwise.
DynArray(DoCast dotype,const S src[]) creates new elements using the "cast" constructor, src is a range of length dotype.getLen(), its members are casted memberwise.
DynArray(DoSwap dotype,T objs[]) creates new elements using the "swap move" approach. I.e. new elements are created using the default constructor and swapped with members of the range objs.
DynArray(DoCreate dotype,Creator creator) uses the given Creator object to create new elements.
DynArray(DoBuildType,Builder builder) uses the given Builder object to create new elements.
// range access T * getPtr(); const T * getPtr() const; const T * getPtr_const() const; ulen getLen() const; ulen getMaxLen() const; ulen getExtraLen() const; // index access T & operator [] (ulen index); const T & operator [] (ulen index) const; T & at(ulen index); const T & at(ulen index) const;
Range access and index access methods are standard. Two additional methods report memory allocation.
getMaxLen() returns the reserved array length (in objects).
getExtraLen() is the extra space available (in objects)
// methods void cloneTo(DynArray<T,Algo> &ret) const; void reserve(ulen extra_len); void erase();
cloneTo() clones the array. The reserved length is also preserved. The type T must be copyable.
reserve() reserves the space for extra_len objects.
erase() erases the array, it gets to the null state, with no objects and no memory allocated.
// shrink ulen shrink(ulen delta_len); bool shrink_one(); ulen shrink_all(); void shrink_extra(); void shrink_reserve(ulen maxlen); void shrink_reserve();
shrink() destroys the last up to delta_len elements of the array. It returns the number of elements destroyed.
shrink_one() destroys the last element (if any). It returns true, if the element is destroyed, and false if the array is empty.
shrink_all() destroys all array elements. It returns the number of elements destroyed.
These three methods doesn't change the reserved array length.
shrink_extra() shrinks the memory block, returning the extra memory to the heap. After this method the reserved array length becomes equal to the array length.
shrink_reserve(ulen maxlen) may shrink the memory block to store the given number of elements. It gives a more precise control over the reserved memory. It works only if the following natural condition satisfied: maxlen<getMaxLen() and maxlen>=getLen().
shrink_reserve() works as shrink_reserve(ulen maxlen) with maxlen equals "double size" of the actual array length.
// extend PtrLen<T> extend_raw(ulen delta_len); PtrLen<T> extend_default(ulen delta_len); template <class ... SS> PtrLen<T> extend_fill(ulen delta_len,SS && ... ss); PtrLen<T> extend_copy(ulen delta_len,const T src[]); template <class S> PtrLen<T> extend_cast(ulen delta_len,const S src[]); PtrLen<T> extend_swap(ulen delta_len,T objs[]); template <class Creator> PtrLen<T> extend(ulen delta_len,Creator creator); template <class Builder> PtrLen<T> extend(Builder builder);
extend...() is a family of methods, which extends the array with number elements. They differs in element construction ways. All of them, except the last, has the first argument delta_len, which is the number of new elements. The return value is the range of these new elements. extend...() are transactional, i.e. if the method has failed, then the array remains in the original state, an exception is thrown.
extend_raw() for POD types leaves new elements uninitialized. For other types it works like extend_default().
extend_default() creates new elements using the default constructor.
extend_fill() creates new elements using some constructor, the specified arguments are forwarded to this constructor.
extend_copy() creates new elements using the copy constructor, src is a range of length delta_len, its members are copied memberwise.
extend_cast() creates new elements using the "cast" constructor, src is a range of length delta_len, its members are casted memberwise.
extend_swap() creates new elements using the "swap move" approach. I.e. new elements are created using the default constructor and swapped with members of the range objs.
Two final extend() are generic. The first of them uses the given Creator object to create new elements, and the second uses the Builder. See below explanations about Creators and Builders.
// append T * append_raw(); T * append_default(); template <class ... SS> T * append_fill(SS && ... ss); T * append_copy(const T &src); T * append_swap(T &obj); template <class Creator> T * append(Creator creator);
append...() is a family of methods to append one element to the array. They are similar to the correspondent extend...() methods and do exactly the same with delta_len equals 1. The return value is a pointer to the created element.
// apply template <class FuncInit> void apply(FuncInit func_init); template <class FuncInit> void apply(FuncInit func_init) const; template <class FuncInit> void apply_const(FuncInit func_init) const; template <class FuncInit> void applyReverse(FuncInit func_init); template <class FuncInit> void applyReverse(FuncInit func_init) const; template <class FuncInit> void applyReverse_const(FuncInit func_init) const;
apply...() methods are standard.
// swap/move objects void objSwap(DynArray<T,Algo> &obj); explicit DynArray(ToMoveCtor<DynArray<T,Algo> > obj); DynArray<T,Algo> * objMove(Place<void> place); };
DynArray is swappable and movable.
RefArray and AtomicRefArray are copyable arrays with efficient copy constructors. It's assumed, the type T is copyable. Multiple copies of arrays may share the same state. The state has a reference counter, which is used to end its life-time. The only difference between RefArray and AtomicRefArray is the former uses the atomic reference counting to be viable in a multi-threaded environment.
RefArray has a simulated value semantic. It means, that you may consider different copies of an array as independent variables, despite they may share the state. That is because RefArray provides only a constant access to elements. So far you don't violate this constantness (using the const-cast, for example), you may safely assume that each copy is different. To modify the array you have to call the method modify() (or modifyReverse()). This method "unshares" the array, if necessary, and gives a non-constant access to elements. modifyReverse() is doing the same thing as modify(), but gives a "reversed" range of elements.
template <class T,class Algo=ArrayAlgo<T> >
class RefArray
{
....
public:
// constructors
RefArray();
template <class S>
explicit RefArray(std::initializer_list<S> il);
explicit RefArray(ulen len);
RefArray(ulen len,ulen maxlen);
RefArray(DoReserveType,ulen maxlen);
explicit RefArray(DoRaw dotype);
template <class ... SS>
explicit RefArray(DoFill dotype,SS && ... ss);
RefArray(DoCopy dotype,const T src[]);
template <class S>
RefArray(DoCast dotype,const S src[]);
RefArray(DoSwap dotype,T objs[]);
template <class Creator>
RefArray(DoCreate dotype,Creator creator);
template <class Builder>
RefArray(DoBuildType,Builder builder);
~RefArray();
// range access
const T * getPtr() const;
const T * getPtr_const() const;
ulen getLen() const;
ulen getMaxLen() const;
ulen getExtraLen() const;
// index access
const T & operator [] (ulen index) const;
const T & at(ulen index) const;
// methods
PtrLen<T> modify();
PtrLenReverse<T> modifyReverse() { return RangeReverse(modify()); }
void cloneTo(RefArray<T,Algo> &ret) const;
void reserve(ulen extra_len);
void erase();
// shrink
ulen shrink(ulen delta_len);
bool shrink_one();
ulen shrink_all();
void shrink_extra();
void shrink_reserve(ulen maxlen);
void shrink_reserve();
// extend
PtrLen<T> extend_raw(ulen delta_len);
PtrLen<T> extend_default(ulen delta_len);
template <class ... SS>
PtrLen<T> extend_fill(ulen delta_len,SS && ... ss);
PtrLen<T> extend_copy(ulen delta_len,const T src[]);
template <class S>
PtrLen<T> extend_cast(ulen delta_len,const S src[]);
PtrLen<T> extend_swap(ulen delta_len,T objs[]);
template <class Creator>
PtrLen<T> extend(ulen delta_len,Creator creator);
template <class Builder>
PtrLen<T> extend(Builder builder);
// append
T * append_raw();
T * append_default();
template <class ... SS>
T * append_fill(SS && ... ss);
T * append_copy(const T &src);
T * append_swap(T &obj);
template <class Creator>
T * append(Creator creator);
// apply
template <class FuncInit>
void apply_modify(FuncInit func_init);
template <class FuncInit>
void apply(FuncInit func_init) const;
template <class FuncInit>
void applyReverse_modify(FuncInit func_init);
template <class FuncInit>
void applyReverse(FuncInit func_init) const;
// swap/move objects
void objSwap(RefArray<T,Algo> &obj);
explicit RefArray(ToMoveCtor<RefArray<T,Algo> > obj);
RefArray<T,Algo> * objMove(Place<void> place);
};
The RefArray methods are mostly the same as DynArray methods. The differences are: index and range access methods gives only the constant access, and new class-specific methods modify() and modifyReverse() exist.
apply_modify() applies the functor, given by a Functor Init, to array elements. The array is unshared first.
applyReverse_modify() applies the functor, given by a Functor Init, to array elements in the reverse order. The array is unshared first.
apply() applies the functor, given by a Functor Init, to array elements. This is a constant method.
applyReverse() applies the functor, given by a Functor Init, to array elements in the reverse order. This is a constant method.
AtomicRefArray methods shrink_extra() and shrink_reserve() are not working, if the array is shared.
Collector is not an array! The purpose of this container is to be an efficient collector of elements. This container stores a sequence of elements in a list of arrays. So appending and extending operations are the most efficient. At desired moment you can copy or move this sequence into true array. Or you can "flat" the Collector itself.
template <class T,class Algo=ArrayAlgo<T> >
class Collector : NoCopy
{
....
public:
// constructors
static const ulen DefaultBlockLen = 1024 ;
static const ulen MinBlockLen = 10 ;
explicit Collector(ulen block_len=DefaultBlockLen);
~Collector();
The argument of the Collector constructor is the number of elements in the single element block. The default value is 1024.
// methods ulen getLen() const; void erase(); template <class Container> void extractTo(Container &ret) { Container temp(DoBuild,Extractor(this)); Swap(temp,ret); } template <class Container> void copyTo(Container &ret) const { Container temp(DoBuild,Copyrator(this)); Swap(temp,ret); } PtrLen<T> flat();
Collector does not provide a direct access to its content.
getLen() is the number of the collected elements.
erase() cleanup the container and put it into the null state.
extractTo() moves the content to another (array) container. The target container must have the Build constructor. Collector becomes empty after this operation.
copyTo() copies the content to another (array) container. The target container must have the Build constructor.
flat() rebuilds the internal data storage, making it continuous. It returns the range of elements. This range remains valid after extend or append operations (but may become invalid after any other modifying operations).
// shrink ulen shrink(ulen delta_len); bool shrink_one(); ulen shrink_all(); // extend PtrLen<T> extend_raw(ulen delta_len); PtrLen<T> extend_default(ulen delta_len); template <class ... SS> PtrLen<T> extend_fill(ulen delta_len,SS && ... ss); PtrLen<T> extend_copy(ulen delta_len,const T src[]); template <class S> PtrLen<T> extend_cast(ulen delta_len,const S src[]); PtrLen<T> extend_swap(ulen delta_len,T objs[]); template <class Creator> PtrLen<T> extend(ulen delta_len,Creator creator); template <class Builder> PtrLen<T> extend(Builder builder); // append T * append_raw(); T * append_default(); template <class ... SS> T * append_fill(SS && ... ss); T * append_copy(const T &src); T * append_swap(T &obj); template <class Creator> T * append(Creator creator);
shrink...(), extend...() and append...() methods are the same as for DynArray.
// swap/move object void objSwap(Collector<T,Algo> &obj); explicit Collector(ToMoveCtor<Collector<T,Algo> > obj); Collector<T,Algo> * objMove(Place<void> place); };
Collector is swappable and movable.
CCore Array implementation is based on the Array Algorithm Packages. The default package is the ArrayAlgo.
template <class T,class Flags=NoThrowFlags<T> > struct ArrayAlgo;
The exact implementation depends on the kind of T.
If the type T defines the inner type ArrayAlgoType, then this type will be used as the package.
Otherwise there are two variants: one for the POD types, another for the other (class) types.
ArrayAlgo_class is the generic (class) variant. It is assumed, that the following operations: ~T(), Move(T *,Place<void>) and Swap(T &,T &) are no-throw. The template argument Flags provides two flags: Default_no_throw and Copy_no_throw. The flag is true, if the correspondent constructor (default or copy) is no-throw or does not exist. It's an obligation of the class.
template <class T,class Flags>
struct ArrayAlgo_class : ArrayAlgoMemBase
{
//
// assume ~T() , Move(T *,Place<void>) , Swap(T &,T &) no-throw
//
//
// Create...() : clean on throw
//
enum PropFlagType
{
Default_no_throw = Flags::Default_no_throw,
Copy_no_throw = Flags::Copy_no_throw,
MoveTo_exist = true
};
static PtrLen<T> Create_raw(Place<void> place,ulen len);
static PtrLen<T> Create_default(Place<void> place,ulen len);
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss);
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]);
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]);
static PtrLen<T> Create_swap(Place<void> place,ulen len,T objs[]);
//
// using Creator
//
template <class Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator);
//
// Single
//
static T * Create_swap(Place<void> place,T &obj) noexcept( EnableNoExcept && Default_no_throw );
//
// ProvideLen() : double extension
//
static ulen ProvideLen(ulen len,ulen maxlen,ulen extra_len);
//
// MoveTo() : no-throw
//
static PtrLen<T> MoveTo(T *ptr,ulen len,Place<void> place) noexcept(EnableNoExcept);
//
// single Destroy() : no-throw
//
static void Destroy(T *ptr) noexcept(EnableNoExcept);
//
// Destroy() : no-throw
//
static void Destroy(T *ptr,ulen len) noexcept(EnableNoExcept);
//
// Guards
//
class BuildGuard;
class CreateGuard;
class CreateGuard_nothrow;
template <bool no_throw> class CreateGuardNoThrow;
};
The package has the following members.
Flags Default_no_throw and Copy_no_throw are copied from the Flags.
Flag MoveTo_exist is always true.
Create_...() creates a range of objects of the type T at the given place. To create an object, the correspondent constructor is called. Objects are created in the ascending order. If some constructor throw an exception, then the previously constructed objects are destroyed and the exception is propagated. The range of the created objects is returned. The first two arguments are: the place to construct and the number of elements to construct. The place must be properly aligned and the memory space must be large enough to contain the required number of objects.
Create_raw() and Create_default() use the default constructor.
Create_fill() uses a constructor with the given set of arguments for each object.
Create_copy() uses the copy constructor. The arguments are memberwise selected from the provided range of objects.
Create_cast() uses the "cast" constructor. The arguments are memberwise selected from the provided range of objects.
Create_swap() uses the default constructor and the swap operation to create objects. The arguments for the swap are memberwise selected from the provided range of objects.
Create() uses the given creator for the object creation. See below about creators.
The single Create_swap() function "creates-swap" a single object.
ProvideLen() is used to reallocate an array. It is called if there is no sufficient memory to extend the array. The len is the array length, the extra_len is the number of extra objects to be constructed, the maxlen is the allocated length. The length returned is sufficient to extend the array and at least double of the maxlen. An exception is thrown in case of overflow.
MoveTo() moves the given range to a new place. The old place becomes a raw memory. The range of new objects is returned.
Single Destroy() destroys the object (but don't free the memory).
Range Destroy() destroys the given range of objects.
There are four inner "guard" classes. They are used to created a range of objects. Guards are responsible for the object destruction in case of failure.
class BuildGuard : NoCopy
{
Place<void> place;
T *ptr;
ulen len;
public:
explicit BuildGuard(Place<void> place_) : place(place_),ptr(place_),len(0) {}
~BuildGuard() { if( len ) Destroy(ptr,len); }
Place<void> at() const { return place; }
void operator ++ () { place+=sizeof (T); len++; }
PtrLen<T> disarm() { return Range(ptr,Replace_null(len)); }
};
BuildGuard is used to create a range of objects. The constructor argument is the place for the range. It must be properly aligned and the memory space must be large enough to store the range.
at() is the current place for the object creation.
operator ++ () must be called after the successful creation of an object at the current position, it moves to the next object position.
disarm() is called after the desired number of objects are created. It "disarms" the guard and returns the created range.
The BuildGuard destructor destroys the created objects. It must be disarmed to prevent the destruction.
class CreateGuard : public BuildGuard
{
public:
CreateGuard(Place<void> place,ulen /*final_len*/) : BuildGuard(place) {}
~CreateGuard() {}
};
CreateGuard is used for creation a range of objects with the given length. Constructor's arguments are: the place of the range and the final number of objects. The remaining methods are the same as for BuildGuard. Using CreateGuard you must create the exact number of objects.
class CreateGuard_nothrow : NoCopy
{
Place<void> place;
T *ptr;
ulen final_len;
public:
CreateGuard_nothrow(Place<void> place_,ulen final_len_) : place(place_),ptr(place_),final_len(final_len_) {}
Place<void> at() const { return place; }
void operator ++ () { place+=sizeof (T); }
PtrLen<T> disarm() { return Range(ptr,final_len); }
};
CreateGuard_nothrow is a "no-throw" variant of the CreateGuard. It is used for the creation of a range of objects with the given length, if there will be no exceptions during the objects construction.
template <bool no_throw>
class CreateGuardNoThrow : NoCopy
{
public:
CreateGuardNoThrow(Place<void> place,ulen final_len);
~CreateGuardNoThrow();
};
CreateGuardNoThrow is the one of the CreateGuard and CreateGuard_nothrow, depending on the no_throw template parameter.
Below is the implementation of the generic Create, it uses the CreateGuardNoThrow.
template <class Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( EnableNoExcept && Creator::NoThrow )
{
CreateGuardNoThrow<Creator::NoThrow> guard(place,len);
FunctorTypeOf<Creator> func(creator);
for(; len ;len--,++guard) func(guard.at());
return guard.disarm();
}
ArrayAlgo_pod is the POD variant.
template <class T>
struct ArrayAlgo_pod : ArrayAlgoMemBase
{
//
// Create...() : clean on throw
//
enum PropFlagType
{
Default_no_throw = true,
Copy_no_throw = true,
MoveTo_exist = true
};
static PtrLen<T> Create_raw(Place<void> place,ulen len);
static PtrLen<T> Create_default(Place<void> place,ulen len);
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss);
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]);
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]);
static PtrLen<T> Create_swap(Place<void> place,ulen len,T objs[]);
//
// using Creator
//
template <class Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( EnableNoExcept && Creator::NoThrow );
//
// Single
//
static T * Create_swap(Place<void> place,T &obj) noexcept(EnableNoExcept);
//
// ProvideLen() : double extension
//
static ulen ProvideLen(ulen len,ulen maxlen,ulen extra_len);
//
// MoveTo() : no-throw
//
static PtrLen<T> MoveTo(T *ptr,ulen len,Place<void> place) noexcept(EnableNoExcept);
//
// single Destroy() : empty
//
static void Destroy(T *ptr) {}
//
// Destroy() : empty
//
static void Destroy(T *ptr,ulen len) {}
//
// Guards
//
class BuildGuard;
class CreateGuard;
class CreateGuard_nothrow;
template <bool no_throw> class CreateGuardNoThrow;
};
Flags Default_no_throw, Copy_no_throw and MoveTo_exist are all true.
Destroy() functions are empty.
Create_raw() is not using default initialization. It leaves the memory uninitialized.
ArrayAlgo_mini is the mini variant without object moving. It is assumed only, that the destructor ~T() is no-throw. Swap and move are not used.
template <class T,class Flags>
struct ArrayAlgo_mini : ArrayAlgoMemBase
{
//
// assume ~T() no-throw
//
//
// Create...() : clean on throw
//
enum PropFlagType
{
Default_no_throw = Flags::Default_no_throw,
Copy_no_throw = Flags::Copy_no_throw,
MoveTo_exist = false
};
static PtrLen<T> Create_raw(Place<void> place,ulen len);
static PtrLen<T> Create_default(Place<void> place,ulen len);
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss);
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]);
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]);
//
// using Creator
//
template <class Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( EnableNoExcept && Creator::NoThrow );
//
// single Destroy() : no-throw
//
static void Destroy(T *ptr) noexcept(EnableNoExcept);
//
// Destroy() : no-throw
//
static void Destroy(T *ptr,ulen len) noexcept(EnableNoExcept);
//
// Guards
//
class BuildGuard;
class CreateGuard;
class CreateGuard_nothrow;
template <bool no_throw> class CreateGuardNoThrow;
};
The flag MoveTo_exist is false.
The following functions: Create_swap(), ProvideLen(), MoveTo() are omitted. Array, constructed with this algorithm package, cannot be extended beyond the initial allocation length.
Creator is a functor, creating objects. It looks like this:
class Creator // copy efficient { .... public: enum NoThrowFlagType { NoThrow = .... }; Creator(....); T * operator () (Place<void> place) noexcept(NoThrow); };
Or like this:
class Creator // copy efficient functor initializer { .... public: enum NoThrowFlagType { NoThrow = .... }; Creator(....); class FunctorType : NoCopy // heavy functor { .... public: explicit FunctorType(Creator init); ~FunctorType(); T * operator () (Place<void> place) noexcept(NoThrow); }; };
You may use a Creator in a generic array "Creator" constructors and methods.
Builder is a functor, creating a range of objects. It looks like:
class Builder // copy efficient { public: Builder(....); ulen getLen() const; PtrLen<T> operator () (Place<void> place) const; // may create up to getLen() objects };
Or like this:
class Builder // copy efficient functor initializer { public: Builder(....); ulen getLen() const; class FunctorType : NoCopy // heavy functor { .... public: explicit FunctorType(Builder init); ~FunctorType(); PtrLen<T> operator () (Place<void> place) const; // may create up to getLen() objects }; };
Builder reports the maximum object number it will create through the method getLen(). operator () gets the place for the range of getLen() elements, it either creates the range of objects up to this length and returns it, or leaves the memory raw and throws an exception.
You may use a Builder in a generic array "Builder" constructors and methods.
There is a list of standard creators.
/* struct Creator_default<T,bool no_throw> */ template <class T,bool no_throw> struct Creator_default { enum NoThrowFlagType { NoThrow = no_throw }; Creator_default() {} T * operator () (Place<void> place) noexcept( EnableNoExcept && no_throw ) { return new(place) T(); } }; /* struct Creator_fill<T,SS> */ template <class T,class ... SS> struct Creator_fill { enum NoThrowFlagType { NoThrow = false }; ForwardTuple<SS...> ss; explicit Creator_fill(SS && ... ss_) : ss( std::forward<SS>(ss_)... ) {} T * operator () (Place<void> place) { T *ret; ss.call( [&ret,place] (SS && ... ss) { ret=new(place) T( std::forward<SS>(ss)... ); } ); return ret; } }; /* struct Creator_copy<T,bool no_throw> */ template <class T,bool no_throw> struct Creator_copy { enum NoThrowFlagType { NoThrow = no_throw }; const T *src; explicit Creator_copy(const T *src_) : src(src_) {} T * operator () (Place<void> place) noexcept( EnableNoExcept && no_throw ) { return new(place) T(*(src++)); } }; /* struct Creator_cast<T,S> */ template <class T,class S> struct Creator_cast { enum NoThrowFlagType { NoThrow = false }; const S *src; explicit Creator_cast(const S *src_) : src(src_) {} T * operator () (Place<void> place) { return new(place) T(*(src++)); } }; /* struct Creator_swap<T,Algo> */ template <class T,class Algo> struct Creator_swap { enum NoThrowFlagType { NoThrow = Algo::Default_no_throw }; T *objs; explicit Creator_swap(T *objs_) : objs(objs_) {} T * operator () (Place<void> place) noexcept( EnableNoExcept && Algo::Default_no_throw ) { return Algo::Create_swap(place,*(objs++)); } };
All default algorithm packages inherit the base class ArrayAlgoMemBase.
struct ArrayAlgoMemBase
{
static void * MemAlloc(ulen len) { return ::CCore::MemAlloc(len); }
static bool MemExtend(void *mem,ulen len) { return ::CCore::MemExtend(mem,len); }
static bool MemShrink(void *mem,ulen len) { return ::CCore::MemShrink(mem,len); }
static void MemFree(void *mem) { ::CCore::MemFree(mem); }
};
This class defines default memory-management functions, used by arrays to allocate, extend, shrink and release memory blocks. If you define a custom algorithm package for your purpose, you may define custom memory allocation functions with the following semantic.
MemAlloc() allocates a memory block of the required length. The block is aligned. An exception is thrown in case of error.
MemFree() releases the previously allocated memory block. The function is never called with the null argument.
MemExtend() tries to extend the previously allocated memory block length to be at least the given argument. If the return value is true, then the attempt was successful.
MemShrink() shrinks the memory block length to be at least the given argument. The return value is never used.
The NoThrowFlags structure is a Property Bag with two flags: Default_no_throw and Copy_no_throw. The flag is true, if the correspondent object constructor does not exist or no-throw. These flags are used to optimize algorithm implementations. The structure is a default "flags provider" for the ArrayAlgo class.
The NoThrowFlags extracts the value of a flag from the inner declaration in the class if such declaration exists:
class SomeClass { public: enum NoThrowFlagType { Default_no_throw = ...., Copy_no_throw = .... }; }; NoThrowFlags<SomeClass>::Default_no_throw == SomeClass::Default_no_throw NoThrowFlags<SomeClass>::Copy_no_throw == SomeClass::Copy_no_throw
If such declaration does not exist, it falls to Meta::HasNoThrowDefault and Meta::HasNoThrowCopy meta-functions. These meta-functions are defined in the target PlatformBase.h. They may be defined like this:
/* struct HasNoThrowDefault<T> */ template <class T> struct HasNoThrowDefault { enum RetType { Ret = !std::is_default_constructible<T>::value || std::is_nothrow_default_constructible<T>::value }; }; /* struct HasNoThrowCopy<T> */ template <class T> struct HasNoThrowCopy { enum RetType { Ret = !std::is_copy_constructible<T>::value || std::is_nothrow_copy_constructible<T>::value }; };
The NoThrowFlags is implemented in such a way, that it will emit a warning, if one of these flags is false. This behavior is not desirable and it is highly recommended to design common classes either without the default or copy constructor, or with efficient ones.
The following class can be used to include no-throw flags in a class definition, simply specify it as the public base class.
/* struct NoThrowFlagsBase */
struct NoThrowFlagsBase
{
// no-throw flags
enum NoThrowFlagType
{
Default_no_throw = true,
Copy_no_throw = true
};
};


Contents Introduction How TLATeX Typesets the Specification How TLATeX Typesets Comments Using LaTeX Commands to Format Comments
The toolbox pretty prints a module by calling the TLATeX program. TLATeX is a Java program for typesetting TLA+ specifications with LaTeX. It was written by Leslie Lamport, based on ideas by Dmitri Samborski.
TLATeX's output should be good enough for most users. Later sections describe how you can get TLATeX to do a better job, and will explain what happened in the unlikely case that it produces weird output. However, if you happen to use any of the two-character sequences
`~ `^ `.in a comment, you'd better read section How TLATeX Typesets Comments.
TLATeX should typeset the specification itself pretty much the way you would want it to. It preserves most of the meaningful alignments in the specification. For example, if the specification contains
Action == /\ x' = x - y /\ yy' = 123 /\ zzz' = zzz
then the /\
and
=
symbols will be aligned in the output. Extra
spaces in the input will be reflected in the output. However, TLATeX
treats 0 and 1 space between symbols the same, so
x+y
and x + y
produce the same output, but
x + y
produces extra space
around the +
.
TLATeX typesets the single TLA+ module that must appear in the input file. It will also typeset any material that precedes and follows the module as if it were a comment. However, that text won't be shaded.
TLATeX does not check that the specification is syntactically correct
TLA+ input. However, it will report an error, which will be
reported to you by the Toolbox, if the specification
contains an illegal lexeme, such as a semicolon (;
).
`
has special meaning to
TLATeX. Enclosing a word in single-quotes like `foo'
is
harmless, while ``
and ''
are
just typeset as double-quotes.
But beware of an unmatched left-quote and of the following
two-character sequences:
`~ `^ `.See below for further details about what single-quotes and these special sequences mean.
TLATeX distinguishes between one-line and multi-line comments. A one-line comment is any comment that is not a multi-line comment. Multi-line comments can be typed in any of the following three ways:
(*************************) (* This is the text of a *) (* multi-line comment. *) (*************************) \******************** \* This is the text \* of the comment. \******************** (* This is the text of the comment. *)
In the first two ways, the (*
or
\*
characters on the left must all be aligned, and
the last line of *
characters is optional.
In the first way, nothing may appear to the right of the
comment--otherwise, the input is considered to be a sequence of
separate one-line comments. In a multi-line comment, TLATeX usually
considers a sequence of non-blank lines to be a single paragraph, in
which case it will typeset them as one paragraph and ignore the line
breaks in the input.
TLATeX does its best to do a sensible job of typesetting comments.
You can help it by ending each sentence with a period (.
) and by
adding blank lines to indicate logical separation of items.
There are three ways in which TLATeX can mess up the typesetting of comments:
-
, should be typeset differently from ordinary
text. Identifiers should be italicized, and the minus in the
expression x-y
should be typeset differently from the dash
in x-ray
. TLATeX gets this right most of the time, but it
does make mistakes.
You can tell TLATeX to treat something as part of a specification
by putting single quotes (`
and ')
around it. You can tell
TLATeX to treat something as ordinary text by putting `^
and ^'
around it--for example:
\*********************************** \* To find the latest value of `bar', \* see `^http::/frob/bar^'. \***********************************But, this is seldom necessary. TLATeX usually does the right thing.
WARNING: Do not put any character between `^
and ^'
except letters, numbers, and ordinary punctuation. In
particular, do not put any of the following characters
between `^
and ^'
:
_ ~ # $ % ^ & < > \ "See the section below on using LaTeX commands in comments for further information about what can go between
`^
and ^'
.
\*********************** \* gnat: A tiny insect. \* \* gnu: A short word. \***********************You can tell TLATeX to typeset a sequence of lines precisely the way they appear in the input, using a fixed-width font, by enclosing the lines with `. and .' , as in:
\********************************************** \* The following picture explains everything: \* \* `. ----------- -------- \* | Processor |------->| Memory | \* ----------- -------- .' \**********************************************Using
`.
and .'
is the only reasonable thing to do for a
diagram. However, if you know (or want to learn) LaTeX, the
section below on using LaTeX commands in comments will explain
how you can get TLATeX to do a good job of formatting things like
lists and tables.
TLATeX ignores any (*
... *)
comment that appears within another comment. So, you can get it not
to typeset part of a comment by enclosing that part between (*
and *)
But a better way to omit part of a comment is to enclose it between `~
and ~'
.
`^
and ^'
in a comment into the
LaTeX input file exactly as it appears. This allows you to insert
LaTeX formating commands in comments. There are two ways to use this.
`^
and ^'
. That text is typeset as one or
more separate paragraphs whose prevailing left margin is determined by
the position of the `^
. For example,
the input
\********************************** \* The first comment paragraph. \* \* The second comment \* paragraph. \* \* `^ Some LaTeX-formated \* text ^' \**********************************causes the LaTeX-formated text to be typeset in a separate paragraph whose prevailing left margin is the same as in the second comment paragraph.
`^
and ^'
in LR mode for a one-line
comment and in paragraph mode for a multi-line comment. The LaTeX
file produced by TLATeX defines a "describe" environment that is
useful for formating text in a multi-line
`^ ... ^'
. This
environment is the same as the standard LaTeX "description"
environment, except that it takes an argument, which should be the
widest item label in the environment. For example, the input might
contain
\*********************** \* `^ \begin{describe}{gnat:} \* \item[gnat:] A tiny insect. \* \* \item[gnu:] A short word. \* \end{describe} ^' \***********************
Warning: An error in a LaTeX command inside
`^ ... ^'
text
can
cause TLATeX not to produce any output.
TLATeX has a feature that is not relevant to use with the Toolbox
that involves putting code between `~
and ~'
. Unless you are also using
TLATeX outside the Toolbox and know what you're doing, do
not put `~
or ~'
in comments.


We extend interfaces!
- orchestrate transparent vortals
- strategize collaborative users
- leverage compelling e-business
- engineer cross-platform ROI
- iterate visionary synergies
- synergize integrated e-business
- reinvent impactful models
- syndicate proactive portals
- aggregate collaborative eyeballs
- reintermediate bricks-and-clicks web services
- whiteboard open-source portals
- grow integrated partnerships
- unleash seamless vortals


| Module | ActionController::Filters::ClassMethods |
| In: |
vendor/rails/actionpack/lib/action_controller/filters.rb
|
The passed filters will be appended to the array of filters that run after actions on this controller are performed.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 461 461: def append_after_filter(*filters, &block) 462: filter_chain.append_filter_to_chain(filters, :after, &block) 463: end
If you append_around_filter A.new, B.new, the filter chain looks like
B#before A#before # run the action A#after B#after
With around filters which yield to the action block, before and after are the code before and after the yield.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 484 484: def append_around_filter(*filters, &block) 485: filter_chain.append_filter_to_chain(filters, :around, &block) 486: end
The passed filters will be appended to the filter_chain and will execute before the action on this controller is performed.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 446 446: def append_before_filter(*filters, &block) 447: filter_chain.append_filter_to_chain(filters, :before, &block) 448: end
Returns an array of Filter objects for this controller.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 536 536: def filter_chain 537: if chain = read_inheritable_attribute('filter_chain') 538: return chain 539: else 540: write_inheritable_attribute('filter_chain', FilterChain.new) 541: return filter_chain 542: end 543: end
The passed filters will be prepended to the array of filters that run after actions on this controller are performed.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 467 467: def prepend_after_filter(*filters, &block) 468: filter_chain.prepend_filter_to_chain(filters, :after, &block) 469: end
If you prepend_around_filter A.new, B.new, the filter chain looks like:
A#before B#before # run the action B#after A#after
With around filters which yield to the action block, before and after are the code before and after the yield.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 498 498: def prepend_around_filter(*filters, &block) 499: filter_chain.prepend_filter_to_chain(filters, :around, &block) 500: end
The passed filters will be prepended to the filter_chain and will execute before the action on this controller is performed.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 452 452: def prepend_before_filter(*filters, &block) 453: filter_chain.prepend_filter_to_chain(filters, :before, &block) 454: end
Removes the specified filters from the after filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 521 521: def skip_after_filter(*filters) 522: filter_chain.skip_filter_in_chain(*filters, &:after?) 523: end
Removes the specified filters from the before filter chain. Note that this only works for skipping method-reference filters, not procs. This is especially useful for managing the chain in inheritance hierarchies where only one out of many sub-controllers need a different hierarchy.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 511 511: def skip_before_filter(*filters) 512: filter_chain.skip_filter_in_chain(*filters, &:before?) 513: end
Removes the specified filters from the filter chain. This only works for method reference (symbol) filters, not procs. This method is different from skip_after_filter and skip_before_filter in that it will match any before, after or yielding around filter.
You can control the actions to skip the filter for with the :only and :except options, just like when you apply the filters.
# File vendor/rails/actionpack/lib/action_controller/filters.rb, line 531 531: def skip_filter(*filters) 532: filter_chain.skip_filter_in_chain(*filters) 533: end


RT @Walldo: worst dystopian cyberpunk future ever RT @coindesk: Mr Bitcoin sighting at the #BitcoinBowl
12/26/2014, 11:15:08 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @Walldo: worst dystopian cyberpunk future ever RT @coindesk: Mr Bitcoin sighting at the #BitcoinBowl
12/26/2014, 11:15:08 PM
Favs: 0
Retweets: 0
link


Notes by Mark Harris / @HolyHaddock
Expected errors can be handled without Exceptions!
Which maintains referential transparency
Generic types and higher order functions make this practical.
Reimplemented in the samples and exercises.
A lot of the combinators were the same as the collections.
A way to make partial functions total.
Particuarly when there isn't any detail to include or act on.
"A collection of zero or one elements."
First time the book talks about "lifting" and "contexts".
Higher kinded types often referred to as "contexts".
And "pure" functions that operate in those contexts are "lifted".
Similar to the way a function might be used in map
.
map2
, map3
etc... Are combinators replacing for-comprehensions?
Make partial functions total...
And provide useful data to act on!
Return actionable data
Combine errors
Bias.
map2 etc
ScalaUtils defines a biased Either:
Or[Exception,Result]
scala.util.Try
Lessons / differences from checked exceptions
sidebar: f(x,a,b) vs x.f(a,b)


Project name
Slide in
Push
Reveal
Off canvas navbar
Link
Link
Link
Dropdown
Action
Another action
Something else here
Nav header
Separated link
One more separated link
DJ CSI


This is an [audience](/concepts/audience.htm) that describes the
access levels supported by forms.
"audience" : {
"admin": {},
"fill": "anyone"
}
# Administrating the form: `"admin"`
The **admin** access allows any operations that can be performed on
the form.
It includes **fill** access.
# Filling the form: `"fill"`
The **fill** access allows:
- Reading a form's meta-data (but not all fields)
- Filling the form. Which instances can be filled depends on the
ownership of those instances. For `"contact"` ownership, for example,
a contact may only fill his own instance.
- Viewing any filled form instance they can re-fill.


In the Tizen Web UI framework, the application page structure is based on a header and content elements:
The header is placed at the top, and displays the page title.
The content is the section below the header, showing the main content of the page.
The footer is placed at the bottom, and can include buttons.
The following table describes the specific information for each section.
| Base | Description |
|---|---|
| Page Handling | Show Reference for page handling. |
| Popup Handling | Show Reference for popup handling. |