In the context of React and state management, a reducer is a pure function that takes the previous state and an action, and returns the next state:
Here are the three main aspects of the reducer pattern:
A higher-order component (HOC) is a function that takes a component and returns a new component:
In the context of Redux, we’ll be using this pattern with the
connect
function in order to “enhance” the components of our
application with the ability to read values from the Redux store and
dispatch actions to update the store.
Without a state management system like Redux, our only notion of state is at the level of each component and all interactions must be achieved with “prop drilling”, passing data and state management functions down the component tree. Redux is all about consolidating this and managing application-level state.
We can still work with useState
for managing state at the
component level, but for bigger-picture concerns of our application we’ll
make the Redux store our single source of truth.
Redux uses a strict unidirectional data flow to keep everything organized:
An action is simply an object with this format:
const action = {
type: 'UPDATE_TITLE' // action types are UPPER_CASE string constants by convention
payload: 'New Title' // data needed to update state
}
In Redux, we take the pattern one step further by defining functions called action creators. These are exactly what they sound like, and their only purpose is to simply return an action.
// updateTitle action creator
export const updateTitle = (newTitle) => {
return { type: "UPDATE_TITLE", payload: newTitle };
};
connect
Since we’ve learned the reducer pattern, we already understand the fundamentals of Redux. The Redux store is just a “state container” that stores application state and uses reducers to update state in a predictable way.
So how do we interact with the store from our React components? We wrap
our application with <Provider>
and then use the
connect
function on each component to make the Redux store
available from that component.
connect
takes two arguments corresponding to the two
direction of communication (receiving values from the store, and updating
it). Here’s what they mean:
mapStateToProps
: which parts of application-level state are
relevant to you (the component)? Let me (Redux) know and I’ll keep you
up to date, sending over those values directly as props whenever the
store is updated.
mapDispatchToProps
: in what specific ways would you (the
component) like to be able to update the store? List each action here
and I’ll provide a corresponding function for each one, passed to you as
props. When you’re looking to update application-level state, just call
one of those functions and you’re done. I’ll handle all the reducer-y
stuff for you.
When we connect a component to the Redux store, we’re providing a helpful interface to be able to update our component with the latest application-level state, and also trigger updates to the application-level state from our component.
The way we actually set things up is a bit complex, but the goals behind this pattern are intuitive. Just remember that the whole idea is for components to be able to communicate with the store, to both read and update application state. Our component receives the most up-to-date values from the store as props, and to update the store we just call functions that are also passed to the component as props.
Here’s a visual summary showing how we set up Redux and
connect
a component to be able to read state values from the
store (mapStatetoProps
) and also update the store by
dispatching reducer actions (mapDispatchToProps
):
Both of these arguments are functions that return objects:
const mapStateToProps = state => {
// map each value to be read from the store to a prop
return {
editing: state.editing,
title: state.title
};
};
const mapDispatchToProps = dispatch => {
// build a dispatching function from each action creator
return {
updateTitle: newTitle => dispatch(updateTitle(newTitle)),
toggleEditing: () => dispatch(toggleEditing()),
// other actions here
};
export default connect(mapStateToProps,mapDispatchToProps)(Title);
connect
is itself a higher order function that
returns a higher order component, which we then immediately
invoke on our Title component in order to “enhance” it. (That’s a lot to
take in, and if all this functional programming stuff feels like Inception
to you, you’re not alone. But the “enhancement” we’re going for with all
this is simply the ability to interact with the store.)
The key idea to remember here is:
we connect
commponents so that they can communicate with
the Redux store.
Once we’ve wired up our <Provider>
and
connect
with all of this boilerplate code, most of the
complexity is abstracted away and each component is enhanced with this
convenient interface to interact with the store:
In Redux we generally use a slightly different pattern than what we saw
with the useReducer
hook. Rather than dispatching actions
directly from our components, we define action creators. Then we
use those action creators to define simple functions that our components
can call directly in order to update the store. That mapping happens in
the second argument to connect
,
mapDispatchToProps
.
Thanks to connect
, we can now just call the function
props.updateTitle
from within our component, and the right
action type and payload will be dispatched to the reducer. This pattern of
mapping action creators to functions with the same name allows
React Redux to simplify things one step further, working some magic behind
the scenes. Rather than writing all of this:
const mapDispatchToProps = (dispatch) => {
return {
updateTitle: (newTitle) => dispatch(updateTitle(newTitle)),
toggleEditing: () => dispatch(toggleEditing()),
};
};
We can instead use this “object shorthand” format for
mapDispatchToProps
:
// This works exactly the same as the more verbose version above
// ES6 object shorthand for {updateTitle: updateTitle, toggleEditing: toggleEditing}
const mapDispatchToProps = { updateTitle, toggleEditing };
(If you’re curious: behind the scenes, React Redux calls
bindActionCreators({updateTitle, toggleEditing}, dispatch)
to
convert the shorthand object into the full mapping function.)
We’ll almost always just use the shorthand, as it’s useful in making
connect
easier to use. But understanding what
mapDispatchToProps
does will help a lot in understanding how
Redux works. As you’re starting out, try writing it out the long way a few
times and then refactoring to the object shorthand. By doing this you’ll
become really comfortable with connect
and all of the
patterns in play here.
Redux is a predictable state container based on the reducer pattern, and it’s often used with React to manage application-level state. To connect our components to the Redux store:
<Provider><App/></Provider>
. The Provider
component (from react-redux) provides the store, allowing every
component in the app tree to access the Redux store.
connect
on each component that needs to read from and
update the store. Most components will need only a small subset of the
application state, and many components may not need to use connect at
all. We use these two arguments of connect
to define the
interface between the component and the store:
mapStateToProps
(read interface): a function that returns
an object, mapping specific values from the Redux state object to props
that will be passed into the current component
mapDispatchToProps
(write interface): an object containing
the relevant action creators your component will use to update
the store. The true form of mapDispatchToProps
is in a
format similar to mapStateToProps
, a function that returns
an object. But as long as we adhere to the standard pattern with action
creators we can use this more convenient object shorthand.


Menu
Choose an action
Home
Setting
Reset
Help
Switch Theme
PC version
Query Web Framework Title
Please load base file first.
Prev
Next
Query Page Footer


above |
Tui The Joyous, Lake |
|
below |
Tui The Joyous, Lake |
The Joyous. Success.
Perseverance is favorable.
Lakes resting on one another:
The image of the Joyous.
Thus the superior man joins with his friends
For discussion and practice.
Nine at the beginning means:
Contented joyousness. Good fortune.
Nine in the second place means:
Sincere joyousness. Good fortune.
Remorse disappears.
Six in the third place means:
Coming joyousness. Misfortune.
Nine in the fourth place means:
Joyousness that is weighed is not at peace.
After ridding himself of mistakes a man has joy.
Nine in the fifth place means:
Sincerity toward disintegrating influences is dangerous.
Six at the top means:
Seductive joyousness.


Synopsis
Marquis de Sade, a French aristocrat, philosopher and writer of explicit sexual works, was born in Paris in 1740. His writings depict violence, criminality and blasphemy against the Catholic Church. During the French Revolution he was an elected delegate to the National Convention. The last 13 years of his life were spent in an insane asylum. He died in 1814.
Early Life
Donatien Alphonse François, best known as Marquis de Sade, was born in Paris, France on June 2, 1740. His father was a diplomat in the court of Louis XV, and his mother was a lady-in-waiting. From the start, de Sade was raised with servants who flattered his every whim. Not long into his childhood, his father abandoned his mother, and his mother took refuge in a convent. By the age of 4, de Sade was known as a rebellious and spoiled child with an ever-growing temper. He once beat the French prince so severely that he was sent to the south of France to stay with his uncle, an abbot of the church. During his stay, while he was 6 years old, his uncle introduced him to debauchery. Four years later, de Sade was sent back to Paris to attend the Lycée Louis-le-Grand. After misbehaving in school, he was subject to severe corporal punishment, namely flagellation.


From here you can translate a template from SendGrid to SparkPost. To get started, paste your SendGrid template into the editor on the left below.


How do you resize the canvas? All the samples so far have used a fixed size canvas meaning the canvas started at one size and stays the same size forever. Here's what you need to know to change the size of the canvas.
Every canvas has 2 sizes. The size of its drawingbuffer. This is how many pixels are in the canvas. The second size is the size the canvas is displayed. CSS determines this size.
You can set the size of the canvas's drawingbuffer in 2 ways. One using HTML
<canvas id="c" width="400" height="300"></canvas>
The other using JavaScript
<canvas id="c" ></canvas>
JavaScript
var canvas = document.getElementById("c");
canvas.width = 400;
canvas.height = 300;
As for setting a canvas's display size if you don't have any CSS that affects the canvas's display size the display size will be the same size as its drawingbuffer. So the 2 examples above the canvas's drawingbuffer is 400x300 and its display size is also 400x300.
Here's an example of a canvas who's drawingbuffer is 10x15 pixels that is displayed 400x300 pixels on the page
<canvas id="c" width="10" height="15" style="width: 400px; height: 300px;"></canvas>
or for example like this
<style>
#c {
width: 400px;
height: 300px;
}
</style>
<canvas id="c" width="10" height="15"></canvas>
If we draw a single pixel wide rotating line into that canvas we'll see something like this
Why is it so blurry? Because the browser takes our 10x15 pixel canvas and stretches it to 400x300 pixels and generally it filters it when it stretches it.
So, what do we do if, for example, we want the canvas to fill the window? Well, first we can get the browser to stretch the canvas to fill the window with CSS. Example
<html>
<head>
<style>
/* make the body fill the window */
html, body {
margin: 0px;
width: 100%;
height: 100%;
overflow: hidden;
}
/* make any canvas fill its container */
canvas {
width: 100%;
height: 100%;
}
<style>
</head>
<body>
<canvas id="c"></canvas>
</body>
</html>
Now we just need to make the drawingbuffer match whatever size the browser has stretched the canvas. We can
do that using clientWidth
and clientHeight
which are properties every element in HTML has that let
JavaScript check what size that element is being displayed.
function resize(canvas) {
// Lookup the size the browser is displaying the canvas.
var displayWidth = canvas.clientWidth;
var displayHeight = canvas.clientHeight;
// Check if the canvas is not the same size.
if (canvas.width != displayWidth ||
canvas.height != displayHeight) {
// Make the canvas the same size
canvas.width = displayWidth;
canvas.height = displayHeight;
}
}
Most WebGL apps are animated so lets call this function just before we render so it will always adjust the canvas to our desired size just before drawing.
function drawScene() {
resize(canvas);
...
And here's that
Hey, something is wrong? Why is the line not covering the entire area?
The reason is when we resize the canvas we also need to call gl.viewport
to set the viewport.
gl.viewport
tells WebGL how to convert from clipspace (-1 to +1) back to pixels and where to do
it within the canvas. When you first create the WebGL context WebGL will set the viewport to match the size
of the canvas but after that it's up to you to set it. If you change the size of the canvas
you need to tell WebGL a new viewport setting.
Let's change resize to handle this. On top of that, since the WebGL context has a reference to the canvas let's pass that into resize.
function resize(gl) {
// Get the canvas from the WebGL context
var canvas = gl.canvas;
// Lookup the size the browser is displaying the canvas.
var displayWidth = canvas.clientWidth;
var displayHeight = canvas.clientHeight;
// Check if the canvas is not the same size.
if (canvas.width != displayWidth ||
canvas.height != displayHeight) {
// Make the canvas the same size
canvas.width = displayWidth;
canvas.height = displayHeight;
// Set the viewport to match
gl.viewport(0, 0, canvas.width, canvas.height);
}
}
Now it's working.
Open that in a separate window, size the window, notice it always fills the window.
I can hear you asking, why doesn't WebGL set the viewport for us automatically when we change the size of the canvas? The reason is it doesn't know how or why you are using the viewport. You could be rendering to a framebuffer or doing something else that requires a different viewport size. WebGL has no way of knowing your intent so it can't automatically set the viewport for you.
If you look at many WebGL programs they handle resizing or setting the size of the canvas in many different ways. If you're curious here are some of the reasons I think the way described above is preferable.


Supercars intervenes after McLaughlin-Pye Instagram spat
by James PaveySupercars is in the process of reiterating its social media policy to teams and drivers following a very public Instagram spat between series champion Scott McLaughlin and Scott Pye.
McLaughlin has been at the centre of controversy after his team was subject to dual controversies in his Bathurst win, with a team orders scandal and subsequent engine breach casting a pall over the 26-year-old’s Mount Panorama breakthrough last month alongside Alex Premat.
On Thursday, McLaughlin was caught up in a war of words with Pye after the latter responded to an article via his Instagram story.
Stream the 2019 Coates Hire Newcastle 500. Live & Ad-Break Free During Racing on KAYO SPORTS. Get your 14 day free trial >
READ MORE
‘Very difficult’: Drivers grapple with Newcastle circuit, weather conditions
Doesn’t get closer than that! Whincup leads Newcastle practice by just 0.0057s
Drama: McLaughlin fastest in opening Newcastle practice despite hairy moment
‘That’s our full focus’: The ‘other’ championship up for grabs
McLaughlin told media on Thursday morning that he “can’t control what other people say, what they do, what they judge us on, whatever”. Later, Pye claimed McLaughlin’s championship season will “forever be tainted” before likening the Shell V-Power Racing driver to disgraced cyclist Lance Armstrong.
“Tired of seeing this rubbish. As one of his ‘peers’ I’ve never spoken to Scotty about this or been critical of the team,” said Pye on his Instagram story.
“But you must understand that some people are going to be pissed off that a car and team that’s been constantly found to be illegal continues to get meaningless penalties.
“Not saying you wouldn’t have won, clearly doing a great job but who knows. It will forever be tainted.”
McLaughlin responded: “We were found once of a technical infringement in one qualifying out of 325 times being scrutineered. So now you understand why I believe this is how our title hasn’t been tainted.”
Pye fired back: “Even if it was once that’s enough to being everything into question. Lance Armstrong (most tested athlete) was caught once, but it ruined his whole career.”
LISTEN TO THE LATEST PODCAST: Mark Skaife l Post-Bathurst Controversy Mkii l Bairdo’s bungle l Triple Eight Turnaround
SUBSCRIBE TO THE SHOW: iTUNES | SPOTIFY | STITCHER
Earlier in the week, Steven Johnson said on The Driver’s Seat radio show that Pye’s Walkinshaw Andretti United team co-owner Ryan Walkinshaw sent a “cheat” text message to McLaughlin.
After Friday’s running at the Coates Hire Newcastle 500, Tickford driver Cameron Waters came to McLaughlin’s aid, saying the social media story has crossed the line.
“For everything that’s happened, it’s not Scotty’s fault,” Waters said.
“He has nothing to do with any of that. It kind of is what it is, what’s happened.
“The things that have happened with the engine stuff, it was pretty minute, it’s happened, move on.
“That’s what’s a bit poor I guess from those guys, saying that kind of s**t.
“I love banter, but that’s s**t. There’s no more to be said, it shouldn’t be said.”


Every Goldfynch plan includes all of its features and benefits . More and more carefully curated features are added continously.
Signup is simple and takes only a few steps. You'll get a free case to try GoldFynch out - no sales call, no credit-card required.
Drag-n-drop your files.
GoldFynch lets you drag-and-drop your files directly into your browser window. Yes, your browser window! No need to install extra software or ask for custom uploads.
Upload any type of file, whatever size.
GoldFynch’s web-based uploader processes even the largest of archives. You can upload whole folders too.
Got compressed files? We'll take care of it.
GoldFynch handles most kinds of archives: ZIPs, PSTs, MBOXs and even other formats you didn’t know you could view.
View files in your browser.
Never leave your browser window, view all your files in GoldFynch. No app switching, no productivity loss.
Keep your files on the Cloud.
No need to download files to view and review them; with GoldFynch's in-built viewer, you never have to worry about downloading and using an external program.
More Secure.
Never having to download files to view means you'd never lose track of them. Keep your files at one place, keep them secure.
Get quick results.
 Quickly sort through documents, emails, images, and many other formats.
Get accurate results.
GoldFynch’s relevance engine finds you what you’re looking for faster and without any complex queries.
Refine your results incrementally.
Narrow in on the information you need. Progressively search within search results to find what you’re looking for.
Documents are automatically processed.
GoldFynch detects scanned images or even PDFs of scanned images and automatically converts them into the right format.
Document processing is free.
GoldFynch’s state-of-the-art OCR comes standard with all plans. You never have to worry about paying extra.
Just Upload and Go
GoldFynch is designed to be completely automatic. Never worry about the kinds and types of documents you're uploading. Just upload and GoldFynch will handle them for you.
Explore these features and more by signing up for GoldFynch. No sales call, no credit-card required..
GoldFynch detects duplicates early.
It will warn you of duplicates even before you upload files.
GoldFynch detects near-duplicates too.
It will also tell you about similar (though not same) documents, and lets you decide what to do with them.
Automatically find Subjects of Interest
GoldFynch will automatically find dates, organizations, people, and locations referred to in a document. Its advanced natural language based analyzers save you effort and time.
GoldFynch is intuitive
Its interface is modern, rich, and carefully designed. No distracting software quirks.
You don’t need technical know-how.
Just work your case and behind the scenes GoldFynch handles a range of complex tasks, like Data Management, and Sharing & Access Control.
You won’t need extensive training
No hefty training fees. No complicated documentation. Get up-and-running in minutes.
GoldFynch runs completely off the Cloud
You don't have to install software on your computer. You won't have to install updates either. Your data is always with you. Access it anytime.
Access it whenever, wherever
You data is always available. We take care of the backups and make sure it's always accessible'
Bank-Grade Security
Your data is protected by state-of-the-art security. It's only accessible by you.
No more load files
But if you have them, GoldFynch will handle them. And if you need them, it will export them for you.
Smooth GoldFynch Transition
GoldFynch integrates and processes the years of data you’ve accumulated with your current case management software.
No Hidden Fees, No Unnecessary Charges
Just create a case and pay the fixed monthly cost. You never have to worry about extra storage or processing charges.
Simple and Predictable Pricing
Cases have fixed prices, so it's easy for you to manage costs.
Easy Upgrades
GoldFynch will track your plan usage and as your needs grow it will show you how to upgrade your case’s plan.
Everything Included
When you sign up for GoldFynch you get everything it has to offer. You never have to pay to unlock added features. Yes, it includes automatic OCR!
Get New Features Automatically
GoldFynch is continuously evolving. And you automatically get access to new features as they are developed and become available.
We will give you a free case to test drive GoldFynch when you sign up. No credit-card required.


Single-cell CRISPR screens provide unprecedented insights into gene regulation and other facets of human genome biology. However, the analysis of these screens poses significant statistical and computational challenges. sceptre
(pronounced “scepter”) is a methodology and associated R package for rigorously identifying regulatory relationships in single-cell CRISPR screen experiments. sceptre
tests whether a given perturbation is associated with the change in expression of a given gene using the intuitive and powerful conditional randomization test.
You can interact with the package in several ways.
Demo: A small demo illustrating the core features of sceptre
is available here. We recommend working through the demo to get a quick (5 minutes) feel for how the method works.
Moderately-sized analysis: If you are running an analysis of moderate size (i.e., the data fit into memory and you are using a single computer), see the tutorial running a moderately-sized analysis.
Large-scale analysis: If you are running a large-scale analysis (i.e., the data do not fit into memory or you are using multiple nodes on a computer cluster), see the tutorial running sceptre at scale.
Note: sceptre
currently applies to high multiplicity-of-infection (MOI; >5 gRNAs/cell) single-cell CRISPR screen data. sceptre
has not yet been carefully vetted in low-MOI settings. We are working on implementing such an extension, but for the time being, please be cautious in attempting to apply sceptre
to low-MOI data.
You can install the development version of the package from Github with the following command:
install.packages("devtools")
::install_github("katsevich-lab/sceptre") devtools
You can browse the source code on Github here.
Note that sceptre has been tested only in R versions >=3.5 in both macOS systems and Linux systems.
Methods paper: T Barry, X Wang, J Morris, K Roeder, E Katsevich. “Conditional resampling improves calibration and sensitivity in single-cell CRISPR screen analysis.” Preprint available on bioRxiv.
Application paper: J Morris, Z Daniloski, J Domingo, T Barry, M Ziosi, D Glinos, S Hao, E Mimitou, P Smibert, K Roeder, E Katsevich, T Lappalainen, N Sanjana. “Discovery of target genes and pathways of blood trait loci using pooled CRISPR screens and single cell RNA sequencing.” Preprint available on bioRxiv.
We are grateful to Analytics at Wharton for supporting the development of this software.


You know I don't know, baby
What the hell went wrong
It's no easy way out of this turmoil
Don't know where we're heading
How to stop the pain
What to say or do to make it go away
It's off the track and a long way back
Just leave it alone
It's off the track and a long way back
Move on to the next one
It's like a long cold winter
And dark endless nights
It takes forever to shake it off your mind
Can't find the ticket out of this place
Try to run away
It slaps you in the face
It's off the track and a long way back
Just leave it alone
It's off the track and a long way back
Move on to the next one
[Solo]
Going down the same old lane
There's nothing more to gain
Keep trying but the weather won't change
The black cloud behind you
Bitching up a storm
No way to get your ass out of this turmoil
You'll be damned
if you do
You'll be damned if you do
It's off the track and a long way back
Just leave it alone
It's off the track and a long way back
Move on to the next one
Come along there's good times waiting down the line
Hurry up when you get the call don't waste your time
Tonight you can be anyone you wanna be
Don't hesitate, set yourself free
Walk through that door and you will see
You got the key to the secret vault
It's the key to all the fun
And we're not cheap, take what you need
There's enough for everyone
So, leave everything behind
Come on and join the ride
Tonight we'll find our way to the ultimate high
To the ultimate high
Get up don't wait around for a second chance
Go ahead 'cause you never know how long it lasts
Tonight it's all yours, just take it all in
Let the demons take your for a spin
No one to aks what you've done or where you've
been
You got the key to the secret vault
It's the key to all the fun
And we're not cheap, take what you need
There's enough for everyone
So, leave everything behind
Come on and join the ride
Tonight we'll find our way to the ultimate high
[Solo]
So, leave everything behind
Come on and join the ride
Tonight we'll find our way to the ultimate high
To the ultimate high
You got the key to the secret vault
It's the key to all the fun
And we're not cheap, take what you need
There's enough for everyone
So, leave everything behind
Come on and join the ride
Tonight we'll find our way to the ultimate high
So, leave everything behind
Come on and join the ride
Tonight we'll find our way to the ultimate high
To the ultimate
high
To the ultimate high
beware of what you say
beware of what you tell
what do you see
if you look around?
society
is going down
and what about me?
and what about you?
What do we know?
What do we think?
How do they use
technology?
and what about me?
and what about you?
Don't doubt it
they want to control
everything
welcome to the puppet show
we all are sheeps
people want to know
and you wanna give
them what they want
What is the price?
What is it cost?
the privacy
is getting lost?
and what about me?
and what about you?
social media
is exposing you
don't you really see
they trail what you do?
We're gonna ride together gonna lose wherever
burn the wheels until the dawn
take a road to anywhere
going after the unknown
Just go GO GO on the way playing to knock down the wind
we will GO for the sun dying on the horizon
dying on the horizon yeah
(chorus)
shadows of the past
fading in the dust
time goes away
the roar of the engine
is the soundtrack of our life
along the path
this is what we want
we're partners in crime
we are again
on the road
on the trail
We're gonna ride together
do the best trip ever
by the route of the outlaws
where the wolves seek for a prey
and the hawks circle above
just go GO GO never know
what is gonna be out there
we will GO anywhere
we don't
need nothing else
we don't need nothing else yeah
HEY!
HEY!
HEY!
(chorus)
shadows of the past
fading in the dust
time goes away
the roar of the engine
is the soundtrack of our life
along the path
this is what we want
we're partners in crime
we are again
on the road
on the trail
HEY!
HEY!
HEY!
Electric girl I know you're sorry
'bout the million burning souls,
Your scarlet rose's speaking secrets
on the road to the end of us all.
And now you're crawling through the briars,
see if they can follow you all.
Redwitch
Leave trails for them straight to the sun,
Orchid girls love whispering Moths.
Evening stars are bleeding on the horizon,
Goddess shine in new-born devastation.
Now on your way to this temple
milking every woman around,
unmovable oh secret mountain
for you only way to collide.

Redwitch
Leave trails for them straight to the sun,
Orchid girls love whispering Moths.
Evening stars are bleeding on the horizon,
Goddess shining new-born devastation.

See what's on your soul...
Rain is to dissolve...
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannah
Rain in Savannahs
Pictures of chaos fill our screens day and night
Is this sensational or is it merely playtime?


@Mihailo i "fixed" the adaptivepow, but i dont think it was a bug exactly. my guess is that you were mining with not so many cores, maybe even just 1. that would make the variance very high and in that case it would make the diff all the way to mindiff, which can be mined pretty fast, even with one core. which makes it look like a big hashrate increase.
so, what i did was make new adaptivepow=N values. using values of 3, 4, 5, 6, 7 you can have different levels of sensitivity. the more normal miners you have, the smaller the number can be. so without many miners, then adaptivepow=7 might make sense, but the higher the number the less responsive it will be to hashrate increases.
for a chain without block rewards, that probably isnt a big concern, so i would make a chain with adaptivepow=6 or 7


| Overview | Module | Use | Devguide | Index |
| Nested Modules | Services | Singletons | Interfaces | Structs | Exceptions | Enums | Typedefs | Constant Groups |
| module text |
|
| Nested Modules | |
| fieldmaster | |
| textfield |
| Services | |
| AccessibleEndnoteView | The accessible view of endnotes. |
| AccessibleFootnoteView | The accessible view of footnotes. |
| AccessibleHeaderFooterView | The accessible view of headers and footers. |
| AccessiblePageView | The accessible view of pagees. |
| AccessibleParagraphView | The accessible view of a paragraph fragment. |
| AccessibleTextDocumentPageView | The accessible page preview of a text document. |
| AccessibleTextDocumentView | The accessible view of a text document. |
| AccessibleTextEmbeddedObject | The accessible view of an inactive embedded object. If an embedded object gets active, the active document gets an accessible object tree of its own. This tree is not a subtree of the object that supports this service but of the document service itself. The tree exist only until the ovject is deactivated. |
| AccessibleTextFrameView | The accessible view of text frames. |
| AccessibleTextGraphicObject | The accessible view of graphics. |
| AdvancedTextDocument | [ DEPRECATED ] An advanced text document is an extension of a hypertext document which can also contain text-frames, foot- and endnotes, and some other advanced contents. |
| AutoTextContainer | provides access to groups of text blocks. |
| AutoTextEntry | provides access to a text block in a group of an AutoTextContainer. |
| AutoTextGroup | provides access to text blocks in a group. |
| BaseFrame | specifies the base service of text frames, graphic objects, and embedded objects |
| BaseFrameProperties | specifies the properties that are provided by all text frames, graphic objects, embedded objects and frame styles. |
| BaseIndex | specifies the basic service of different indexes within a document. |
| BaseIndexMark | is a TextRange which is explicitly marked as an index entry. This is the base service of index marks for DocumentIndex, ContentIndex, and UserIndex. |
| Bibliography | specifies service of bibliography within a text document. |
| Bookmark | A bookmark is a TextContent, which is like a jump target or a label. |
| Bookmarks | This service specifies a collection of Bookmarks. |
| Cell | represents a singe cell within a text table. |
| CellProperties | service that holds all cell properties of a text table cell in a text document. |
| CellRange | area of cells within a text table. |
| ChainedTextFrame | extends a TextFrame which shares the same Text with other ChainedTextFrame instances that will make the text flow through the chained frames. The text flows in the next frame if there is no space left in the current frame. |
| ChapterNumberingRule | describes the rules for chapter numbering in a text document. |
| ContentIndex | specifies service of content indexes within a document. |
| ContentIndexMark | is a TextRange which is explicitly marked as an index entry for a ContentIndex. |
| DefaultNumberingProvider | provides access to language dependent numbering types and supports formatting of those numberings. |
| Defaults | provides default settings of a text component for paragraph and character properties. |
| DependentTextField | is a TextField which is not specified by itself, but dependent on a TextFieldMaster. |
| DocumentIndex | specifies service of content indexes within a document. |
| DocumentIndexFormat | [ DEPRECATED ] specifies the formatting of document indexes. |
| DocumentIndexLevelFormat | This service provides access to the structure of the levels of document indexes. |
| DocumentIndexMark | is a TextRange which is explicitly marked as an index entry for a DocumentIndex. |
| DocumentIndexMarkAsian | is a TextRange which is explicitly marked as an index entry for a DocumentIndex. For Asian languages the user can provide an additional string which is used for sorting. If the user does not provide these strings, they are not considered for sorting. |
| DocumentIndexParagraphStyles | provides access to the names of paragraph styles that are included in content indexes of user defined indexes. The element type is sequence of string. |
| DocumentIndexes | provides access to all indexes in a document. |
| DocumentSettings | describes properties that apply to the whole text document. |
| Endnote | This service specifies a an endnote in a TextDocument. |
| EndnoteSettings | provides access to the settings of footnotes or endnotes in a (text) document. |
| Footnote | This service specifies a footnote or an endnote in a TextDocument. |
| FootnoteSettings | provides access to the settings of footnotes or endnotes in a (text) document. |
| Footnotes | provides access to the footnotes or endnotes of a (text) document. |
| GenericTextDocument | A text document is a model component which contains text structured by paragraphs. |
| GlobalDocument | [ DEPRECATED ] Specify the document service of the global text module. |
| GlobalSettings | specifies a service that provides acces to the settings of a text module. |
| HypertextDocument | [ DEPRECATED ] is an extension of a text document which can also contain tables and certain kinds of embedded objects (e.g., graphics). |
| IllustrationsIndex | specifies service of illustration indexes within a document. |
| InContentMetadata | is a TextContent that can be used to attach RDF metadata to a range of text. |
| LineNumberingProperties | provides access to the settings of the line numbering. |
| LineNumberingSettings | [ DEPRECATED ] provides access to the settings of the line numbering. |
| MailMerge | Gives access to mail merge functionality. |
| NumberingLevel | provides access to a numbering level as part of the Numbering Rules. |
| NumberingRules | provides access to the numbering rules. |
| NumberingStyle | specifies a stylesheet numberings within a Text. |
| ObjectIndex | specifies service of object indexes within a document. |
| PageFootnoteInfo | specifies the properties of the footnote area of a page or a page style. |
| PagePrintSettings | These properties describe the way the XPagePrintable interface prints the page on one printer page. |
| Paragraph | is a piece of text which can take its own paragraph-specific attributes (technically, properties). |
| ParagraphEnumeration | provides access to the paragraphs of an XText interface. |
| PrintPreviewSettings | [ DEPRECATED ] These properties describe the printing of the content of a text document. * * |
| PrintSettings | These properties describe the printing of the content of a text document. |
| RedlinePortion | A RedlinePortion is a TextPortion that marks a change that has been recorded by the change tracking. |
| ReferenceMark | is used for cross references in text documents. |
| ReferenceMarks | provides access to the reference marks in a document. |
| Shape | specifies the service of shapes in a text document |
| TableColumns | represents a collection of all columns of a table. |
| TableIndex | specifies service of table indexes within a document. |
| TableRows | represents a collection of all rows of a text table. |
| Text | is an independent piece of text which consists of a series of one or more paragraphs. |
| TextColumns | provides access to columns in text (e.g., in TextFrames ). |
| TextContent | is an object which can be anchored in a text, like instances of TextFrame or TextField. |
| TextContentCollection | Objects of this type are collections of text contents of the same type. |
| TextCursor | A TextCursor is a TextRange which can be moved within a Text object. |
| TextDocument | Specify the document service of the text module. |
| TextDocumentView | specifies the view of a TextDocument. |
| TextEmbeddedObject | provides access to the properties and methods of an embedded object. |
| TextEmbeddedObjects | provides access to all embedded objects in a document. |
| TextField | A TextField is a TextContent which fades its textual representation into the text range to which it is anchored. |
| TextFieldEnumeration | This interface creates an enumeration of all text fields within a text document. |
| TextFieldMaster | A TextFieldMaster specifies important data for its DependentTextFields. |
| TextFieldMasters | This is a collection of instances of TextFieldMaster, defined in a context (e.g. in a document). |
| TextFields | This is a collection of TextField instances. |
| TextFrame | specifies a rectangular shape which contains a Text object and is attached to a piece of surrounding Text. |
| TextFrames | This is the collection of all TextFrame instances within a context (e.g. a document). |
| TextGraphicObject | specifies a graphic which can be embedded in Text. |
| TextGraphicObjects | This is the collection of all TextGraphicObject instances within a context (e.g. a document). |
| TextLayoutCursor | A TextLayoutCursor is a TextRange which can travel within a layout of a Text object. |
| TextPageStyle | represents a page style for a text document. |
| TextPortion | A TextPortion is a piece of text within a paragraph that does not contain changes of its attributes inside. |
| TextPortionEnumeration | This interface creates an enumeration of paragraph within a text document. The elements created by this enumeration contains either parts of text with equal properties or text content elements like text fields, reference marks or bookmarks. |
| TextRange | points to a sequence of characters within a Text. |
| TextRangeContentProperties | describes the structural properties to retrieve text contents. |
| TextRanges | provides a container for XTextRange objects. |
| TextSection | A TextSection is a range of complete paragraphs within a text. |
| TextSections | provides access to the text sections in a text document. |
| TextSortDescriptor | [ DEPRECATED ] describes sort criteria for sorting text. |
| TextSortDescriptor2 | describes sort criterias for sorting paragraphs or table contents in a text document. |
| TextSortable | [ DEPRECATED ] provides an interface for sorting. |
| TextTable | is a table of text cells which is anchored to a surrounding text. |
| TextTableCursor | specifies a cursor in text tables. |
| TextTableRow | specifies the properties of a text table row. |
| TextTables | provides access to all tables in a document. |
| TextViewCursor | A TextViewCursor is a TextRange which can travel within a view of a Text object. |
| UserDefinedIndex | specifies service of user defined indexes within a document. |
| UserIndex | specifies service of user defined indexes within a document. |
| UserIndexMark | is a TextRange which is explicitly marked as an index entry for a UserIndex. |
| ViewSettings | provides access to the settings of the controller of a text document. |
| WebDocument | [ DEPRECATED ] Specify the document service of the web module. |
| Interfaces | |
| XAutoTextContainer | handles blocks of AutoTextEntry. |
| XAutoTextEntry | [ DEPRECATED ] identifies an autotext entry. |
| XAutoTextGroup | The interface provide methods to insert, rename and delete autotext entries from the current autotext group. |
| XBookmarkInsertTool | offers an easy way to insert bookmarks by name. |
| XBookmarksSupplier | provides access to the collection of all bookmarks within this text container. |
| XChapterNumberingSupplier | contains the settings of the chapter numbering in a text document. |
| XDefaultNumberingProvider | provides access to default NumberingRules according to a given locale information. |
| XDependentTextField | makes it possible to attach this TextField to a TextFieldMaster. |
| XDocumentIndex | [ DEPRECATED ] This is the main interface for a document index. |
| XDocumentIndexMark | gives access to the mark of a document index entry. |
| XDocumentIndexesSupplier | gives access to the collection of document indexes. |
| XEndnotesSettingsSupplier | makes it possible to access the FootnoteSettings within the context (e.g. document). |
| XEndnotesSupplier | makes it possible to access the endnotes within the context (e.g. document). |
| XFlatParagraph | provides functionality to ... |
| XFlatParagraphIterator | provides functionality to ... |
| XFlatParagraphIteratorProvider | provides functionality to ... |
| XFootnote | specifies a footnote within a Text. |
| XFootnotesSettingsSupplier | makes it possible to access the FootnoteSettings with the context (e.g. document). |
| XFootnotesSupplier | makes it possible to access the footnotes within the context (e.g. document). |
| XFormField | [ DEPRECATED ] |
| XHeaderFooter | [ DEPRECATED ] |
| XHeaderFooterPageStyle | [ DEPRECATED ] |
| XLineNumberingProperties | contains the settings of the line numbering in a text document. |
| XLineNumberingSupplier | [ DEPRECATED ] contains the settings of the line numbering in a text document. |
| XMailMergeBroadcaster | allows for adding/removing of mail merge event listeners. |
| XMailMergeListener | used to notify listeners about mail merge events. |
| XMarkingAccess | extends a text range by method to modify its position. |
| XModule | [ DEPRECATED ] |
| XMultiTextMarkup | provides functionality to apply multiple text markups in one call. |
| XNumberingFormatter | supports the formatting of numberings in various language environments. |
| XNumberingRulesSupplier | This interface enables the object to handle numbering rules. |
| XNumberingTypeInfo | provides access to the numbering types that are supported by a component. |
| XPageCursor | makes it possible to perform cursor movements between pages. |
| XPagePrintable | Print several pages on one printer page. |
| XParagraphAppend | . |
| XParagraphCursor | makes it possible to move paragraph by paragraph. |
| XRedline | enables creation of redlines (change tracking). |
| XReferenceMarksSupplier | provides access to the reference marks within this context (i.e. document). |
| XRelativeTextContentInsert | [ DEPRECATED ] makes it possible to insert new text contents before or after existing text contents. |
| XRelativeTextContentRemove | [ DEPRECATED ] makes it possible to remove text contents before or after existing text contents. |
| XRubySelection | This interface enables the object to handle list of ruby lines (aka Furigana lines). |
| XSentenceCursor | makes it possible to perform cursor movements through sentences. |
| XSimpleText | is the main interface for a distinct text unit, i.e. the main text of a document, the text for headers and footers or for single cells of a table. |
| XText | extends a XSimpleText by the capability of inserting XTextContents. |
| XTextAppend | . |
| XTextAppendAndConvert | merges the functions of XTextAppend, XTextContentAppend and XTextConvert. |
| XTextColumns | manages columns within the object. |
| XTextContent | enables objects to be inserted into a text and to provide their location in a text once they are inserted into it. |
| XTextContentAppend | . |
| XTextConvert | . |
| XTextCopy | enables a text object to copy attributed text from another text object. |
| XTextCursor | extends a text range by method to modify its position. |
| XTextDocument | is the main interface of a text document. |
| XTextEmbeddedObject | [ DEPRECATED ] f t! |
| XTextEmbeddedObjectsSupplier | provides the collection of all embedded objects within this context (i.e. this document). |
| XTextField | is the base interface for all text fields. |
| XTextFieldsSupplier | makes it possible to access the text fields used in this context (e.g. this document). |
| XTextFrame | provides access to the Text of a TextFrame. |
| XTextFramesSupplier | makes it possible to access the TextFrame instances in this context (e.g. document). |
| XTextGraphicObjectsSupplier | provides access to the collection of all embedded and linked graphics within this context (i.e. within this document). |
| XTextMarkup | provides functionality to markup text. |
| XTextPortionAppend | . |
| XTextRange | describes the object's position in a text. |
| XTextRangeCompare | compares the positions of two TextRanges within a Text. |
| XTextRangeMover | makes it possible to move a text range (e.g. a paragraph by itself) within this text. |
| XTextSection | provide special data of a TextSection. |
| XTextSectionsSupplier | manages the text sections within the context (i.e. the document). |
| XTextShapesSupplier | provides the collection of ::com::sun::star::drawing::TextShapes. |
| XTextTable | manages a text table. |
| XTextTableCursor | The TextTableCursor provide methods to navigate throught the table structure, to merge and split cells |
| XTextTablesSupplier | enables the object to handle text tables. |
| XTextViewCursor | describes a cursor in a text document's view. |
| XTextViewCursorSupplier | supplies access to the cursor in the view. |
| XWordCursor | makes it possible to move a cursor word by word. |
| Structs | |
| GraphicCrop | describes the cropping of graphic objects. Cropping means to show only parts of the object. |
| HoriOrientationFormat | describes the horizontal orientation of an object. |
| MailMergeEvent | represents a mail merge event. |
| SectionFileLink | describes the link for a text section. |
| TableColumnSeparator | The width of the cells of a text table is defined by the position of the separator between neighboring cells. |
| TextColumn | defines a single text column. |
| TextMarkupDescriptor | A descriptor for a single text markup. |
| VertOrientationFormat | describes the vertical orientation of an object. |
| Exceptions | |
| InvalidTextContentException | is thrown whenever a method gets a TextContent as an actual argument when the text content cannot be used for that operation. |
| Enums | |
| HorizontalAdjust | enumeration values define the horizontal adjustments of objects. |
| NotePrintMode | enumeration values are used to define the printing of notes in a document. |
| PageNumberType | determines which page number is displayed in a page number text field. |
| RubyAdjust | These enumeration values describe the adjustment of ruby text. |
| TextContentAnchorType | specify how the text content is attached to its surrounding text. |
| WrapTextMode | enumeration values specify the text wrap around objects in a text. |
| WritingMode | [ DEPRECATED ] this enum covers the different writing directions |
| Typedefs | |
| TextColumnSequence |
| Constant Groups | |
| AuthorDisplayFormat | These constants are used to specify which parts of an author name are displayed in a field. |
| BibliographyDataField | These values define parts of bibliographic data. They are used to create a bibliography in a text document. |
| BibliographyDataType | These values define the type of bibliographic data like book, journal, magazine, etc. |
| ChapterFormat | These constants define the display format of the chapter number in a chapter text field. |
| CharacterCompressionType | These constants define character compression in asian text. |
| ControlCharacter | These constants are the codes for inserting control characters
using |
| DateDisplayFormat | [ DEPRECATED ] This constants define how a date field is formated before it is displayed. The format may also depend on the system or document locale. The samples are in German. |
| DocumentStatistic | These constants are used to specify the type of a document statistic field. |
| FilenameDisplayFormat | These constants are used to specify which parts of an URL are displayed in a field. |
| FontEmphasis | Determins the type and position of an emphasis mark in asian texts. |
| FontRelief | Determins the relief type of a font. |
| FootnoteNumbering | These constants are used to specify the footnote numbering. |
| HoriOrientation | These enumeration values specify the horizontal orientation. |
| LabelFollow | These enumeration values specify character following the list label |
| MailMergeType | Defines the possible output types/devices for mail merge. |
| ParagraphVertAlign | These enumeration values are used to specify the vertical alignment of paragaphs. |
| PlaceholderType | These constants define how the place-holder text fields act in a document. |
| PositionAndSpaceMode | These enumeration values specify the position and space mode for a numbering level |
| PositionLayoutDir | These values specify the layout direction, in which the position attributes of a shape are given |
| ReferenceFieldPart | These constants define how the reference position is displayed in reference text fields. |
| ReferenceFieldSource | These constants define the type of the source of a reference field. |
| RelOrientation | These values define the reference position of relative orientations. |
| SetVariableType | These constants define the type of a variable text field. |
| SizeType | The height value of objects like text frames or table rows may be interpreted in different ways. |
| TemplateDisplayFormat | These constants are used to specify which information about a template is displayed in a field. |
| TextGridMode | this set of constants describes different modes for text grids |
| TextMarkupType | Constants to specify the type of text markup. |
| TimeDisplayFormat | [ DEPRECATED ] This constants define how a time field is formated before it is displayed. The formate may also depend on the system or document locale. |
| UserDataPart | These constants define which part of the user data is displayed in a user data text field (service "sun.one.text.TextField.ExtendedUser") |
| UserFieldFormat | These constants describe how the content of a user text field is formatted. |
| VertOrientation | These enumeration values are used to specify the vertical orientation. |
| WrapInfluenceOnPosition | These values specify the influence of the wrapping style of a floating screen object when it's positioned. |
| WritingMode2 | this set of constants describes different writing directions |
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


A fighting pit represent a specific instance of a battle.
More...
#include <FightingPit.hh>
|
| enum | Level : uint { EASY = 0,
MEDIUM = 1,
HARD = 2,
NONE
} |
| | Complexity of the FightingPit.
|
| |
|
|
static constexpr unsigned | CREATION_ERROR = 0 |
| | used as a wrong id when a fighting pit is wrongly generated
|
| |
|
|
class | FightingPitAnnouncer |
| |
A fighting pit represent a specific instance of a battle.
A fightingpit is composed of:
- a layout (mapping of how the monsters/players are spread on the board)
- a PitContenders object managing all the monsters and their behaviours (scripting)
- a AllyPartyTeams object managing the players, each client has a PartyTeam (multiple party teams possible for one AllyPartyTeams) and the PartyTeam is composed of TeamMember that are the actual characters spread on the gaming board.
- The 18 instances of SideBattle
- See also
- SideBattle
- Examples
- /home/FyS/Project/FyS/services/arena/include/FlatbufferGenerator.hh.
◆ addAuthenticatedUser()
| void fys::arena::FightingPit::addAuthenticatedUser |
( |
std::string |
userName, |
|
|
std::string |
userToken |
|
) |
| |
Add an authenticated player in the fighting pit, the player authentication is not verified an thus must be verified beforehand.
- Parameters
-
| userName | unique name of the player to add |
| userToken | token of the player to add |
◆ addPartyTeamAndRegisterActions()
| void fys::arena::FightingPit::addPartyTeamAndRegisterActions |
( |
std::unique_ptr< PartyTeam > |
pt, |
|
|
cache::Cml & |
cache |
|
) |
| |
Used to add a new party team (incoming player in the fighting pit) and register its action to chai
- Note
- The verification if the fighting pit is in ON_HOLD mode is not done in this function and thus should be done before the PartyTeam object is created.
- Parameters
-
| pt | party team to add |
| cache | retrieving object to find the actions |
◆ continueBattle()
| void fys::arena::FightingPit::continueBattle |
( |
const std::chrono::system_clock::time_point & |
now | ) |
|
◆ disableJoin()
| void fys::arena::FightingPit::disableJoin |
( |
| ) |
|
|
inlinenoexcept |
Disable the ability to join the battle if the fighting pit is currently reachable
◆ forwardActionToTeamMember()
| void fys::arena::FightingPit::forwardActionToTeamMember |
( |
const std::string & |
user, |
|
|
PlayerAction |
action |
|
) |
| |
◆ isBattleOver()
| bool fys::arena::FightingPit::isBattleOver |
( |
| ) |
const |
|
inlinenoexcept |
Check if the battle is done, the winner doesn't matter, this is a status to cleanup the fighting pit when its done
- Returns
- true if the battle is over, false otherwise
◆ isPlayerParticipant()
| bool fys::arena::FightingPit::isPlayerParticipant |
( |
const std::string & |
name, |
|
|
const std::string & |
token |
|
) |
| const |
Check if given player (defined by name/token) is authenticated
- Parameters
-
| name | unique name of the player to check |
| token | token of the player to check |
- Returns
- true if the player is authenticated, false otherwise
The documentation for this class was generated from the following files:
- /home/FyS/Project/FyS/services/arena/include/fightingPit/FightingPit.hh
- /home/FyS/Project/FyS/services/arena/src/fightingPit/FightingPit.cpp


I am a research analyst with J.P. Morgan, covering Non-Agency RMBS within the securitized products research team, where I also interned in 2019. Prior to this role, I was a part of the corporate credit research team, covering High Grade and High Yield Power and Utilities. I graduated in 2020 from The University of Chicago, where I majored in Economics and Statistics, and earned a joint Master's degree in Computer Science in my fourth year of college. My interests lie in research, technology and the markets, which has led me to pursue opportunities at the cross section of Economics, data science and technology. I absolutely love problem-solving and being challenged, and am thankful that I am able to pursue my interests in fixed income research alongside a host of talented individuals.
Throughout my time in college, I was actively engaged in research opportunities in and out of campus. I spent a significant amount of time as research assistant for professors in various fields of Economics, and was a data analyst for the U.S. Peace Corps before landing my current role on the finance side of things. I've loved being able to develop an affinity for quantitative approaches to understanding the real world across various fields, and everyday now I get to apply both these skills and my love for reading and writing to my day to day work. That said, I've always had a passion for education, and am always looking for ways that I can integrate it into my life. I've tutored students all throughout high school and college, and am on the hunt for a way to stay engaged here in NYC. At some point, I'd love to see how I can use technology or technology education to improve classroom performance and financial literacy in schools.
Outside of work, I am deeply involved in the dance world. Having trained in classical ballet, modern and contemporary dance from babyhood, I have been fortunate to have performed on numerous stages at a pre-professional and professional level and participate in the field across different cities over the years. I was Co-Director of UChicago Maya (UChicago's dance company) in college, where I choreographed and performed regularly during the season, on top of managing the logistics of a team of dancers. I continue to train in NYC, where I am now based. I also love netball, water sports, and hiking -- I hope to be able to visit all of America's national parks in my lifetime. Building this website was my first ever self-assigned coding project in the summer of 2017, and I am now well-versed in Python, R and SQL, with experience in front-end web development and some mobile software development. It's been a constant learning process, and that's what's so exciting about this field. Check out some of my past projects below!
A small selection of performances I've danced in and group pieces I've choreographed most recently. The first row features videos of shows I'm proud to have directed, choreographed for and performed in as Co-Director of UChicago Maya for the 2019-20 season. Please refer to each link's description bar for more information on which pieces I specifically choreographed and the nature of each performance.


Class: Aws::ServiceDiscovery::Types::Namespace
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb |
Overview
A complex type that contains information about a specified namespace.
Constant Summary
Instance Attribute Summary
-
#arn ⇒ String
rw
The Amazon
::Aws::ServiceDiscovery::Resource
Name (ARN) that Cloud Map assigns to the namespace when you create it. -
#create_date ⇒ Time
rw
The date that the namespace was created, in Unix date/time format and Coordinated Universal Time (UTC).
-
#creator_request_id ⇒ String
rw
A unique string that identifies the request and that allows failed requests to be retried without the risk of running an operation twice.
-
#description ⇒ String
rw
The description that you specify for the namespace when you create it.
-
#id ⇒ String
rw
The ID of a namespace.
-
#name ⇒ String
rw
The name of the namespace, such as
example.com
. -
#properties ⇒ Types::NamespaceProperties
rw
A complex type that contains information that's specific to the type of the namespace.
-
#service_count ⇒ Integer
rw
The number of services that are associated with the namespace.
-
#type ⇒ String
rw
The type of the namespace.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Aws::Structure#to_h. |
Instance Attribute Details
#arn ⇒ String
(rw)
The Amazon ::Aws::ServiceDiscovery::Resource
Name (ARN) that Cloud Map assigns to the
namespace when you create it.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#create_date ⇒ Time
(rw)
The date that the namespace was created, in Unix date/time format
and Coordinated Universal Time (UTC). The value of CreateDate
is
accurate to milliseconds. For example, the value<PHONE_NUMBER>.087
represents Friday, January 26, 2018 12:11:30.087 AM.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#creator_request_id ⇒ String
(rw)
A unique string that identifies the request and that allows failed requests to be retried without the risk of running an operation twice.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#description ⇒ String
(rw)
The description that you specify for the namespace when you create it.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#id ⇒ String
(rw)
The ID of a namespace.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#name ⇒ String
(rw)
The name of the namespace, such as example.com
.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#properties ⇒ Types::NamespaceProperties (rw)
A complex type that contains information that's specific to the type of the namespace.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#service_count ⇒ Integer
(rw)
The number of services that are associated with the namespace.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end
#type ⇒ String
(rw)
The type of the namespace. The methods for discovering instances depends on the value that you specify:
HTTP
: Instances can be discovered only programmatically, using the Cloud
Map DiscoverInstances
API.
DNS_PUBLIC
: Instances can be discovered using public DNS queries and using the
DiscoverInstances
API.
DNS_PRIVATE
: Instances can be discovered using DNS queries in VPCs and using
the DiscoverInstances
API.
# File 'gems/aws-sdk-servicediscovery/lib/aws-sdk-servicediscovery/types.rb', line 1855
class Namespace < Struct.new( :id, :arn, :name, :type, :description, :service_count, :properties, :create_date, :creator_request_id) SENSITIVE = [] include Aws::Structure end


{{ page.title }}
{% if page.outdated %}
Outdated
This blog post is based on our legacy web app. The functionality still works, but the screenshots and setup instructions are no longer valid. We will be updating this post soon.
You can access the legacy web app at https://legacy.automategreen.com


Parse a BibTeX file to a data.frame to make it accessible for further analysis and visualization.
| Version: | 1.0.1 |
| Imports: | dplyr, stringr, humaniformat, httr |
| Suggests: | testthat, knitr, rmarkdown, ggplot2, tidyr |
| Published: | 2018-06-02 |
| Author: | Philipp Ottolinger [aut, cre], Thomas Leeper [ctb], Maëlle Salmon [ctb], Paul Egeler [ctb] |
| Maintainer: | Philipp Ottolinger <philipp at ottolinger.de> |
| BugReports: | http://github.com/ropensci/bib2df/issues |
| License: | GPL-3 |
| URL: | https://github.com/ropensci/bib2df |
| NeedsCompilation: | no |
| Materials: | NEWS |
| CRAN checks: | bib2df results |
| Reference manual: | bib2df.pdf |
| Vignettes: |
bib2df |
| Package source: | bib2df_1.0.1.tar.gz |
| Windows binaries: | r-devel: bib2df_1.0.1.zip, r-release: bib2df_1.0.1.zip, r-oldrel: bib2df_1.0.1.zip |
| OS X binaries: | r-release: not available, r-oldrel: not available |
| Old sources: | bib2df archive |
Please use the canonical form https://CRAN.R-project.org/package=bib2df to link to this page.


| Lesson 5 |
| Expanding on the last tutorial,
we'll now make the object into TRUE 3D object, rather than 2D objects in a
3D world. We will do this by adding a left, back, and right side to the
triangle, and a left, right, back, top and bottom to the square. By doing
this, we turn the triangle into a pyramid, and the square into a cube.
We'll blend the colors on the pyramid, creating a smoothly colored object, and for the square we'll color each face a different color. |
||
int DrawGLScene(GLvoid) // Here's Where We Do All The Drawing { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer glLoadIdentity(); // Reset The View glTranslatef(-1.5f,0.0f,-6.0f); // Move Left And Into The Screen glRotatef(rtri,0.0f,1.0f,0.0f); // Rotate The Pyramid On It's Y Axis glBegin(GL_TRIANGLES); // Start Drawing The Pyramid
| A few of you have taken the code
from the last tutorial, and made 3D objects of your own. One thing I've
been asked quite a bit is "how come my objects are not spinning on their
axis? It seems like they are spinning all over the screen". In order for
your object to spin around an axis, it has to be designed AROUND that
axis. You have to remember that the center of any object should be 0 on
the X, 0 on the Y, and 0 on the Z. The following code will create the pyramid around a central axis. The top of the pyramid is one high from the center, the bottom of the pyramid is one down from the center. The top point is right in the middle (zero), and the bottom points are one left from center, and one right from center. Note that all triangles are drawn in a counterclockwise rotation. This is important, and will be explained in a future tutorial, for now, just know that it's good practice to make objects either clockwise or counterclockwise, but you shouldn't mix the two unless you have a reason to. We start off by drawing the Front Face. Because all of the faces share the top point, we will make this point red on all of the triangles. The color on the bottom two points of the triangles will alternate. The front face will have a green left point and a blue right point. Then the triangle on the right side will have a blue left point and a green right point. By alternating the bottom two colors on each face, we make a common colored point at the bottom of each face. |
||
glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Front) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f(-1.0f,-1.0f, 1.0f); // Left Of Triangle (Front) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f( 1.0f,-1.0f, 1.0f); // Right Of Triangle (Front)
| Now we draw the right face. Notice
then the two bottom point are drawn one to the right of center, and the
top point is drawn one up on the y axis, and right in the middle of the x
axis. causing the face to slope from center point at the top out to the
right side of the screen at the bottom. Notice the left point is drawn blue this time. By drawing it blue, it will be the same color as the right bottom corner of the front face. Blending blue outwards from that one corner across both the front and right face of the pyramid. Notice how the remaining three faces are included inside the same glBegin(GL_TRIANGLES) and glEnd() as the first face. Because we're making this entire object out of triangles, OpenGL will know that every three points we plot are the three points of a triangle. Once it's drawn three points, if there are three more points, it will assume another triangle needs to be drawn. If you were to put four points instead of three, OpenGL would draw the first three and assume the fourth point is the start of a new triangle. It would not draw a Quad. So make sure you don't add any extra points by accident. |
||
glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Right) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f( 1.0f,-1.0f, 1.0f); // Left Of Triangle (Right) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f( 1.0f,-1.0f, -1.0f); // Right Of Triangle (Right)
| Now for the back face. Again the colors switch. The left point is now green again, because the corner it shares with the right face is green. | ||
glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Back) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f( 1.0f,-1.0f, -1.0f); // Left Of Triangle (Back) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f(-1.0f,-1.0f, -1.0f); // Right Of Triangle (Back)
| Finally we draw the left face. The
colors switch one last time. The left point is blue, and blends with the
right point of the back face. The right point is green, and blends with
the left point of the front face. We're done drawing the pyramid. Because the pyramid only spins on the Y axis, we will never see the bottom, so there is no need to put a bottom on the pyramid. If you feel like experimenting, try adding a bottom using a quad, then rotate on the X axis to see if you've done it correctly. Make sure the color used on each corner of the quad matches up with the colors being used at the four corners of the pyramid. |
||
glColor3f(1.0f,0.0f,0.0f); // Red glVertex3f( 0.0f, 1.0f, 0.0f); // Top Of Triangle (Left) glColor3f(0.0f,0.0f,1.0f); // Blue glVertex3f(-1.0f,-1.0f,-1.0f); // Left Of Triangle (Left) glColor3f(0.0f,1.0f,0.0f); // Green glVertex3f(-1.0f,-1.0f, 1.0f); // Right Of Triangle (Left) glEnd(); // Done Drawing The Pyramid
| Now we'll draw the cube. It's made
up of six quads. All of the quads are drawn in a counter clockwise order.
Meaning the first point is the top right, the second point is the top
left, third point is bottom left, and finally bottom right. When we draw
the back face, it may seem as though we are drawing clockwise, but you
have to keep in mind that if we were behind the cube looking at the front
of it, the left side of the screen is actually the right side of the quad,
and the right side of the screen would actually be the left side of the
quad. Notice we move the cube a little further into the screen in this lesson. By doing this, the size of the cube appears closer to the size of the pyramid. If you were to move it only 6 units into the screen, the cube would appear much larger than the pyramid, and parts of it might get cut off by the sides of the screen. You can play around with this setting, and see how moving the cube further into the screen makes it appear smaller, and moving it closer makes it appear larger. The reason this happens is perspective. Objects in the distance should appear smaller :) |
||
glLoadIdentity(); glTranslatef(1.5f,0.0f,-7.0f); // Move Right And Into The Screen glRotatef(rquad,1.0f,1.0f,1.0f); // Rotate The Cube On X, Y & Z glBegin(GL_QUADS); // Start Drawing The Cube
| We'll start off by drawing the top of the cube. We move up one unit from the center of the cube. Notice that the Y axis is always one. We then draw a quad on the Z plane. Meaning into the screen. We start off by drawing the top right point of the top of the cube. The top right point would be one unit right, and one unit into the screen. The second point would be one unit to the left, and unit into the screen. Now we have to draw the bottom of the quad towards the viewer. so to do this, instead of going into the screen, we move one unit towards the screen. Make sense? | ||
glColor3f(0.0f,1.0f,0.0f); // Set The Color To Green glVertex3f( 1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Top) glVertex3f(-1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Top) glVertex3f(-1.0f, 1.0f, 1.0f); // Bottom Left Of The Quad (Top) glVertex3f( 1.0f, 1.0f, 1.0f); // Bottom Right Of The Quad (Top)
| The bottom is drawn the exact same
way as the top, but because it's the bottom, it's drawn down one unit from
the center of the cube. Notice the Y axis is always minus one. If we were
under the cube, looking at the quad that makes the bottom, you would
notice the top right corner is the corner closest to the viewer, so
instead of drawing in the distance first, we draw closest to the viewer
first, then on the left side closest to the viewer, and then we go into
the screen to draw the bottom two points. If you didn't really care about the order the polygons were drawn in (clockwise or not), you could just copy the same code for the top quad, move it down on the Y axis to -1, and it would work, but ignoring the order the quad is drawn in can cause weird results once you get into fancy things such as texture mapping. |
||
glColor3f(1.0f,0.5f,0.0f); // Set The Color To Orange glVertex3f( 1.0f,-1.0f, 1.0f); // Top Right Of The Quad (Bottom) glVertex3f(-1.0f,-1.0f, 1.0f); // Top Left Of The Quad (Bottom) glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Bottom) glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Bottom)
| Now we draw the front of the Quad. We move one unit towards the screen, and away from the center to draw the front face. Notice the Z axis is always one. In the pyramid the Z axis was not always one. At the top, the Z axis was zero. If you tried changing the Z axis to zero in the following code, you'd notice that the corner you changed it on would slope into the screen. That's not something we want to do right now :) | ||
glColor3f(1.0f,0.0f,0.0f); // Set The Color To Red glVertex3f( 1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Front) glVertex3f(-1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Front) glVertex3f(-1.0f,-1.0f, 1.0f); // Bottom Left Of The Quad (Front) glVertex3f( 1.0f,-1.0f, 1.0f); // Bottom Right Of The Quad (Front)
| The back face is a quad the same as the front face, but it's set deeper into the screen. Notice the Z axis is now minus one for all of the points. | ||
glColor3f(1.0f,1.0f,0.0f); // Set The Color To Yellow glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Back) glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Back) glVertex3f(-1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Back) glVertex3f( 1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Back)
| Now we only have two more quads to draw and we're done. As usual, you'll notice one axis is always the same for all the points. In this case the X axis is always minus one. That's because we're always drawing to the left of center because this is the left face. | ||
glColor3f(0.0f,0.0f,1.0f); // Set The Color To Blue glVertex3f(-1.0f, 1.0f, 1.0f); // Top Right Of The Quad (Left) glVertex3f(-1.0f, 1.0f,-1.0f); // Top Left Of The Quad (Left) glVertex3f(-1.0f,-1.0f,-1.0f); // Bottom Left Of The Quad (Left) glVertex3f(-1.0f,-1.0f, 1.0f); // Bottom Right Of The Quad (Left)
| This is the last face to complete
the cube. The X axis is always one. Drawing is counter clockwise. If you
wanted to, you could leave this face out, and make a box :) Or if you felt like experimenting, you could always try changing the color of each point on the cube to make it blend the same way the pyramid blends. You can see an example of a blended cube by downloading Evil's first GL demo from my web page. Run it and press TAB. You'll see a beautifully colored cube, with colors flowing across all the faces. |
||
glColor3f(1.0f,0.0f,1.0f); // Set The Color To Violet glVertex3f( 1.0f, 1.0f,-1.0f); // Top Right Of The Quad (Right) glVertex3f( 1.0f, 1.0f, 1.0f); // Top Left Of The Quad (Right) glVertex3f( 1.0f,-1.0f, 1.0f); // Bottom Left Of The Quad (Right) glVertex3f( 1.0f,-1.0f,-1.0f); // Bottom Right Of The Quad (Right) glEnd(); // Done Drawing The Quad rtri+=0.2f; // Increase The Rotation Variable For The Triangle rquad-=0.15f; // Decrease The Rotation Variable For The Quad return TRUE; // Keep Going }
| By the end of this tutorial, you
should have a better understanding of how objects are created in 3D space.
You have to think of the OpenGL screen as a giant piece of graph paper,
with many transparent layers behind it. Almost like a giant cube made of
of points. Some of the points move left to right, some move up and down,
and some move further back in the cube. If you can visualize the depth
into the screen, you shouldn't have any problems designing new 3D objects.
If you're having a hard time understanding 3D space, don't get frustrated. It can be difficult to grasp right off the start. An object like the cube is a good example to learn from. If you notice, the back face is drawn exactly the same as the front face, it's just further into the screen. Play around with the code, and if you just can't grasp it, email me, and I'll try to answer your questions. Jeff Molofee (NeHe) * DOWNLOAD Visual C++ Code For This Lesson. * DOWNLOAD Visual Basic Code For This Lesson. ( Conversion by Ross Dawson ) * DOWNLOAD GLUT Code For This Lesson. ( Conversion by Andy Restad ) * DOWNLOAD Cygwin (FREE Language) Code For This Lesson. ( Conversion by Stephan Ferraro ) * DOWNLOAD Delphi Code For This Lesson. ( Conversion by Peter De Jaegher ) * DOWNLOAD MacOS X/GLUT Code For This Lesson. ( Conversion by Raal Goff ) * DOWNLOAD Linux/GLX Code For This Lesson. ( Conversion by Mihael Vrbanec ) * DOWNLOAD Code Warrior 5 Code For This Lesson. ( Conversion by Scott Lupton ) * DOWNLOAD MASM Code For This Lesson. ( Conversion by Nico (Scalp) ) * DOWNLOAD ASM Code For This Lesson. ( Conversion by Foolman ) * DOWNLOAD Visual Fortran Code For This Lesson. ( Conversion by Jean-Philippe Perois ) * DOWNLOAD Linux Code For This Lesson. ( Conversion by Richard Campbell ) * DOWNLOAD Irix Code For This Lesson. ( Conversion by Lakmal Gunasekara ) * DOWNLOAD Solaris Code For This Lesson. ( Conversion by Lakmal Gunasekara ) * DOWNLOAD Mac OS Code For This Lesson. ( Conversion by Anthony Parker ) * DOWNLOAD Power Basic Code For This Lesson. ( Conversion by Angus Law ) * DOWNLOAD BeOS Code For This Lesson. ( Conversion by Chris Herborth ) * DOWNLOAD Java Code For This Lesson. ( Conversion by Darren Hodges ) * DOWNLOAD MingW32 & Allegro Code For This Lesson. ( Conversion by Peter Puck ) * DOWNLOAD Borland C++ Builder 4.0 Code For This Lesson. ( Conversion by Patrick Salmons ) * DOWNLOAD Python Code For This Lesson. ( Conversion by Tony Colston ) |
||


PyroCMS is built to be modular, so creating modules is a pretty simple process. The core modules are
stored in
Each module can contain the following directories: config, controllers, helpers, libraries, models, views, js, css and img. If a module will have a frontend (something that displays to the user) then it should contain at least one controller, and that controller should be the same name as the module.
E.g: addons/modules/blog/controllers/blog.php
The rest of it is pretty much normal CodeIgniter development except for a few things.
Each module contains a details.php file which contains its name, description, version, whether they are available to the backend and/or frontend, etc. This file is only used when installing and uninstalling the module. On install the file is parsed and imported into the database.
Here is the basic structure for the details.php file:
<?php defined('BASEPATH') or exit('No direct script access allowed');
class Module_Polls extends Module {
public $version = '1.0';
public function info()
{
return array(
'name' => array(
'en' => 'Polls'
),
'description' => array(
'en' => 'Create totally awesome polls.'
),
'frontend' => TRUE,
'backend' => TRUE,
'menu' => FALSE
);
}
public function install()
{
// Create polls table
$this->db->query("
CREATE TABLE IF NOT EXISTS `polls` (
`id` tinyint(11) unsigned NOT NULL AUTO_INCREMENT,
`slug` varchar(64) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT
");
// It worked!
return TRUE;
}
public function uninstall()
{
// Get
$this->db->query("DROP TABLE `polls`");
return TRUE;
}
public function upgrade($old_version)
{
// Your Upgrade Logic
return TRUE;
}
public function help()
{
// You could include a file and return it here.
return "Some Help Stuff";
}
}
/* End of file details.php */
The array contains details that will be read and saved to the database on install. You can supply as many extra languages as you like, by default the en version of name and description will be used.
This array will be available in your Public_Controller's and Admin_Controller's via $this->module_details['name']. Notice, name and description will use the current language, not return the whole array.
In normal CodeIgniter there is only one controller class. In PyroCMS there are four. Controller, MY_Controller, Admin_Controller and Public_Controller. To use one of these you can extend them like so:
<?php
class News extends Public_Controller {
function index()
{
$data['message'] = "Hello World!";
// Loads from addons/modules/blog/views/view_name.php
$this->template->build('view_name', $data);
}
}
This page will be available to anyone whether logged in or not and will use the frontend design. That means it will use the current active theme and show any login data and navigation, etc and can be viewed via "http://example.com/modulename".
Admin controllers have a few different properties to them. It will automatically check that a user has permission to be there, and redirect them to a login page if not. This means they either need to have a user role of "admin" or be allowed specific permission to access the module.
<?php
class Admin extends Admin_Controller {
function index()
{
$data['message'] = "Hello logged in admin guy!";
// Loads from addons/modules/blog/views/admin/view_name.php
$this->template->build('admin/view_name', $data);
}
}
This page can be accessed via "http://example.com/admin/modulename".
When you place a module inside the addons/modules directory and go to CP > Modules page, it will "index" the file into the database. If you change the details of this module, you will need to uninstall and delete, or manually change the information in the database. We'll add a "re-index" feature in for v1.1.
The module can be installed in 2 different ways.
If you want to install a module on a server but you don't have access to the filesystem you can upload a zip containing the module through the Control Panel instead, then click install.
To uninstall simply go into the admin, click on "Modules" then click "Uninstall" next to the module you will to uninstall. This will run the uninstall method which should drop any tables.
To disable simply go into the Control Panel, click on "Modules" then click "Disable" next to the module you want to disable. This will disable both on the front end (it will 404 when you try to visit it) and in the Control Panel.
We recommend you use the Database or DBForge libraries for any database interaction (i.e. creating tables). These two libraries are made available to you as follows:
$this->db->query('whatever sql here');
$this->dbforge->create_table('table_name');
You can access any CI library as you normally would inside a Controller, including loading other libraries:
$this->load->library('whatever');
$this->whatever->method();


Favorite Parts
I really love all the episodes in Gintama, especially the ones that are really funny. The anime consistes a range of genres from comedy to action to historcial. It's loads of fun to watch and I never get tired of watching all the episodes for the 5th time. So these are some of my favorite episodes that I found really hilarious and fun to watch.
Episode 153, "Sleep Helps A Child Grow"
Kagura had a really hard time sleeping so she starts distubing Gintoki, telling him to help her sleep. At first he didnt want to help but Kagura wouldnt stop bothering him. So he reluctanly tries too help her sleep. HE firs told her to go job to make herself feel tired. But when she came back she was more energetic. So gintoki to l her to eat a little bit to get rid of her hunger from running to much. BUt hwen she came back she was really full and couldnt go back to sleep.
Episode 151, "A Conversation With A Barber, During A Haircut, Is The Most Pointless Thing In The World "
The odd jobs were trying to help out the barber, as he left to get a manga that he thought he didnt have. The odd jobs were hoping no one would come to the barber shop as they had no idea how to cut other peoples hair. Just as they were hoping that no one was going to come in the barber, a policeman and a joi rebel came in. And just to make matters worst the shogun also took a visit to get his haircut.
Episode 119, "Within Each Box Of Cigarettes, Are One Or Two Cigarettes That Smell Like Horse Dung"
There was a ban in smoking in the community. This was a problem for Toshiro as he was addicted to somking. He tried to quit, but he couldnt handle the addiction so he decided to go travel to a different planet to find a cigarette and have a smoke. The problem was the other planets also were out of cigarette, because a bunch of bandits took all the cigarettes and ran sacked the city that made the cigarettes . So Toshiro went on a mission to find the bandits and save the city that makes the cigarettes. But in order to save the city and find his cigarettes he needs to find all of the ooy gooey balls and take them to the dragon to make his wish come true.
Episode 171, "You Don’t Know What You’ve Got Till It’s Gone"
There was a virus outbreak in edo. Everyone living in Edo had their hair failling off. As odd jobs were having an exsistencial crisis on how they were going to make up for being bald in the show. They thought that some medicine for hair loss would help with the hair falls but it apparently made that hair loss even worst.
References:
- Gintama main Image
- kagura Gif
- Barber epsiode picture
- Episode 119 picture
- Hair loss episode


Grand
Turk:
vine
covering
shrubs
in
open
coppice,
Palm
Grove
community.
Flowers
large,
white.
December
20,
1975
D.
S.
Correli
46544-A
Herbarium
FAIRCHILD
TROPICAL
GARDEN
MM
lllll
WMMM
--
I
I
?
??1
?
???
0
1
cm
2
3
4
5
6
7
8
9
10
.
,
The
New
York
Copyright
reserved
Botanical
Garden
?
4
-V-Ç?
01497854
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high