Class: TPLink::Light
Overview
Control TPLink Dimmable lights
Instance Attribute Summary
Attributes inherited from Device
Instance Method Summary collapse
-
#off ⇒ Object
Turn light off.
-
#on(b = 100) ⇒ Object
Turn light on.
-
#toggle ⇒ Object
Toggle device (turn off if on, on if off).
Methods inherited from Device
Instance Method Details
#off ⇒ Object
Turn light off
20 21 22 |
# File 'lib/tp_link/light.rb', line 20 def off transition_light_state(0, 100) end |
#on(b = 100) ⇒ Object
Turn light on
15 16 17 |
# File 'lib/tp_link/light.rb', line 15 def on(b = 100) transition_light_state(1, b) end |
#toggle ⇒ Object
Toggle device (turn off if on, on if off)
25 26 27 28 29 30 31 |
# File 'lib/tp_link/light.rb', line 25 def toggle if on? off else on end end |


| 020:018 Khan | : |
He said: "This is my stick, whereon I lean, and wherewith I beat down branches for my sheep, and wherein I find other uses." |
| 020:018 Maulana | : |
He said: This is my staff -- I lean on it, and beat the leaves with it for my sheep, and I have other uses for it. |
| 020:018 Pickthal | : |
He said: This is my staff whereon I lean, and wherewith I bear down branches for my sheep, and wherein I find other uses. |
| 020:018 Rashad | : |
He said, "This is my staff. I lean on it, herd my sheep with it, and I use it for other purposes." |
| 020:018 Sarwar | : |
He replied, "It is my staff. I lean on it, bring down leaves for my sheep with it and I need it for other reasons. |
| 020:018 Shakir | : |
He said: This is my staff: I recline on it and I beat the leaves with it to make them fall upon my sheep, and I have other uses for it. |
| 020:018 Sherali | : |
Moses said, 'This is my rod, I lean on it and beat down therewith leaves for my sheep and other uses also I find in it.' |
| 020:018 Yusufali | : |
He said, "It is my rod: on it I lean; with it I beat down fodder for my flocks; and in it I find other uses." |
Concepts/Themes Covered:
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


{% extends 'base.html' %} {% block content %} {% include 'navbar.html' %}
For this project I created a localhost website which was due to be published on June 2018. To do this I used Windows Powershell, pip, python and Django for backend. For frontend I used CSS and HTML.


{{ define "main" }}
I’m passionate about helping businesses and individuals grow their brand through the web in the Akron area or wherever you may be on Earth. Let's get in touch!
Below is a sample of the work I've done over the years, including projects done as a freelancer or just for fun. Your next project idea could be in this showcase!
Have an inquiry about a project you would like me to do or perhaps you just want to say "hi"? You can do so below. Please fill out your name, email and a message. If you're inquiring about a project you would like me to tackle, please give a brief description of the project along with your budget. I will respond back in no later than one business day. Thank you for your interest.


There are some features in GtkStyleContext that were not available in GtkStyle, or were made available over time for certain widgets through extending the detail string in obscure ways. There is a lot more information available when rendering UI elements, and it is accessible in more uniform, less hacky ways. By going through this list you'll ensure your widget is a good citizen in a fully themable user interface.
gtk_style_context_add_region()
. These regions can be
referenced in CSS and the :nth-child pseudo-class may be used to match
the elements depending on the flags passed.
Example 50. Theming widget regions
1 2 3 4 5 6 7 |
GtkNotebook tab { background-color: #f3329d; } GtkTreeView row::nth-child (even) { background-color: #dddddd; } |
If your container renders child widgets within different regions, make it implement GtkContainer get_path_for_child(). This function lets containers assign a special GtkWidgetPath to child widgets depending on their role/region. This is necessary to extend the concept above throughout the widget hierarchy.
For example, a GtkNotebook modifies the tab labels' GtkWidgetPath so the "tab" region is added. This makes it possible to theme tab labels through:
Example 51. Theming a widget within a parent container region
1 2 3 |
GtkNotebook tab GtkLabel { font: Sans 8; } |
gtk_style_context_set_junction_sides()
. It is of course up to the
theme to make use of this information or not.
GtkStyleContext supports implicit animations on state changes for
the most simple case out-of-the-box: widgets with a single animatable
area, whose state is changed with gtk_widget_set_state_flags()
or
gtk_widget_unset_state_flags()
. These functions trigger animated
transitions for the affected state flags. Examples of widgets for
which this kind of animation may be sufficient are GtkButton or
GtkEntry.
If your widget consists of more than a simple area, and these areas
may be rendered with different states, make sure to mark the rendered
areas with gtk_style_context_push_animatable_region()
and
gtk_style_context_pop_animatable_region()
.
gtk_style_context_notify_state_change()
may be used to trigger a
transition for a given state. The region ID will determine the
animatable region that is affected by this transition.


While this site is open, your cpu is mining Monero for me.
You are mining with : 2 CPU-Cores by idle-time of 50%.
Your Hashrate is :
Hashes/s


Address: Oakwood Estate, DLF Phase 2, Sector 25, Gurgaon
Phone: +91<PHONE_NUMBER>
Email<EMAIL_ADDRESS>Website Careerofy.com
Far far away, behind the word mountains, far from the countries Vokalia and Consonantia, there live the blind texts. Separated they live in


Schema Validation Report
Entities: {{items}}
{% for name, r in results %}
{{name}}
Entity Count:
Total: {{total[name]}}
Info: {{aggregates[name]["Info"]["entity"]}}
Warning: {{aggregates[name]["Warning"]["entity"]}}
Violation: {{aggregates[name]["Violation"]["entity"]}}
Totals:
Info: {{aggregates[name]["Info"]["count"]}}
Warning: {{aggregates[name]["Warning"]["count"]}}
Violation: {{aggregates[name]["Violation"]["count"]}}
{% endfor %}


"Life is denied by lack of attention, whether it be to cleaning windows or trying to write a masterpiece."I think it's one of the most true things I've heard.
Nadia Boulanger
It also meshes nicely with Augustine's idea that the present is attention, or at least a projection of attention. On to what, I don't know — eternity?


PAYBACK (1999)
A film review by Steve Kong Edited by Steve Kong Copyright 1999 Steve Kong
Payback is a style-over-substance film and being so it falls into two distinct categories: the occasional good one that is highly entertaining or, more often then not, one that completely fails to entertain and realize only on style to skate by. Which is Payback? And does Payback succeed in entertaining?
Porter (Mel Gibson) is a bad guy, a really bad guy. We see how bad he is as the movie opens. He picks pockets, he steals from the homeless, and he doesn't tip waitresses. He's not a likeable guy by any means, but he's the guy we're stuck with throughout the film. Cool! For once we don't have to follow some ultra-goodie-two-shoes through a film. And this is a nice twist.
So, what's Porter's rub with the world? After robbing some Chinese mobsters of $140,000 using a car and a big crash, Porter is shot and left for dead by his partner in crime and best friend, Val (Gregg Henry). Val steals Porter's $70,000 share of the stolen money. Porter is not dead though and he is out to get his $70,000, no more, no less. As it turns out that Val is part of the mob, or as known in the film as "the outfit", but was kicked out. Val buys himself back into the outfit with the stolen money. Now, not only does Porter have to deal with Val and the Chinese mobsters, he has the outfit on his back also. During the film, Porter rekindles a relationship with a hooker, Rosie (Maria Bello), whom he used to know and she is key to Porter's plans of revenge.
Gibson doesn't do anything special in Payback. His character Porter is nothing more than his Lethal Weapon character Martin Riggs gone bad. Gibson can do this kind of role with his eyes closed; a maniac guy who has no real care for his life, but has subtle humour within.
There are two performers to look for in Payback: Maria Bello and William Devane. The last time I saw Bello was on ER last season. She is wonderful in Payback as the only friend that Porter has. I hope to see Bello in more films soon. Devane is the best thing Payback has. His onscreen presence is a hoot and a holler. I wish that he had more screen time because he had one juicy and funny part. Watch for the scene where he puts on lip-gloss. Devane takes this scene over-the-top and it turns out to be one of the funniest scenes in the film.
Payback is the first film helmed by Brian Helgeland who is better known for his writing: The Postman, L.A. Confidential, and Assassins. He has a steady hand at directing, but he still needs a bit of work at keeping and maintaining tone. At times, the film switches tones abruptly and these switches feel out of place. From time to time the film will go from serious to humourous, not working its way into the humour. This left the audience, and myself, unable to catch some of the humour. There are some funny bits in this film, but they are lost to Helgeland's inability to integrate them well with the serious portions of the film.
The script by Helgeland and Terry Hayes, based on Richard Starks's book The Hunter, is nothing special. I do like how snappy the dialogue was, but next to that, this is just a film about a bad guy getting revenge on bad people. What makes Payback stick out is the bluish tint that is added to the film noir look. This bluish tint comes from the process in which the film was developed. And it is this look that makes up for most of Paybacks style – the film is a work of art.
One thing that stuck out as strange was Lucy Liu's presence in the film. She basically takes her character from Fox's Ally McBeal and turns it up a notch. The sight of her in the film is quite jarring and as I overheard one audience member say, "That Ally McBeal girl being in this film was corny." But, it was cool hearing her say, "Hubba hubba."
Payback does succeed in entertaining, though it's mostly pulp entertainment. The minute you step out of the theatre, most of the film will have slipped from memory. Catch Payback at a matinee showing to see the performances of Maria Bello and William Devane. A warningto those who are weak at the heart, if you're squeamish to violence then Payback is not for you. There are multiple scenes of heavy and graphic violence. Plus, there is some graphic torture scenes.
--- Steve Kong<EMAIL_ADDRESS>recipe for a hard boiled review: one egg, two cups water, a pot, a helluva attitude, and a guy who loves the cinema. i'm your hard boiled movie guide.
http://boiledmovies.sbay.com/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


15 April 1999
Disease Outbreak Reported
While the exact number of encephalitis cases and deaths in Malaysia continues to be tabulated, it is now apparent that the number of cases is no longer increasing, showing that the epidemic is under control. Both Japanese encephalitis virus and a Hendra-like virus (now being designated as Nipah virus) infections have been reported; however, Nipah virus appears to be the predominant pathogen. Cases have almost exclusively occurred in persons in close contact with pigs, especially those working is areas where there is disease in pigs. Pig culling in affected areas is ongoing to control Nipah virus transmission.
Multiple epidemiological studies both in animals and humans are continuing. These include studies to determine the animal species infected by Nipah and to identify the natural reservoir of the virus. Among the studies in humans, emphasis is on the identification of the specific risk factors for infection. Investigators from the United States Centers for Disease Control and Prevention and from other countries, including Australia and Japan, are working with the Malaysian government to conduct these studies.


You have been authenticated with:
but we can't find any profile that includes this ID.
If this is not a mistake, and you wish to create a new profile
then please confirm below & access using a new profile.
If you want to associate this ID with an existing profile:
If you think you already have an existing account, and you were just trying to
associate a new login with your existing account, here's what to do:
- Press cancel, and then log in to your existing account
- then choose to add more logins to associate this ID with that profile


For a better experience while using our Service, OpenTournament may require you to provide us with certain personally identifiable information, including but not limited to your name, phone number, and postal address. The information that OpenTournament collect will be used to contact or identify you. OpenTournament will not give any Data to third-party services.
OpenTournament is not responsible for, and expressly disclaims all liability for, damages of any kind arising out of use, reference to, or reliance on any information contained within the site. While the information contained within the site is periodically updated, no guarantee is given that the information provided in this Web site is correct, complete, and up-to-date.
Although the OpenTournament Web site may include links providing direct access to other Internet resources, including Web sites, OpenTournament is not responsible for the accuracy or content of information contained in these sites.
Links from OpenTournament to third-party sites do not constitute an endorsement by OpenTournament of the parties or their products and services. The appearance on the Web site of advertisements and product or service information does not constitute an endorsement by OpenTournament, and OpenTournament has not investigated the claims made by any advertiser. Product information is based solely on material received from suppliers.
Tobias Matt
76185 Karlsruhe
Gellertstr 36
Contact me


This is a paragraph.
This paragraph contains a lot of lines in the source code, but the browser ignores it.
This paragraph contains a lot of spaces in the source code, but the browser ignores it.
This is a link This is a linkDo not forget to buy milk today.
My favorite color is blue red.
My favorite color is blue red.
This is subscripted text.
This is superscripted text.
Here is a quote from WWL's website:
For 50 years, WWF has been protecting the future of nature. The world's leading conservation organization, WWF works in 100 countries and is supported by 1.2 million members in the United States and close to 5 million globally.
WWF's goal is to: Build a future where people live in harmony with nature.
The WHO was founded in 1948.
Written by John Doe.The Scream by Edvard Munch. Painted in 1893.
This text will be written from right to left| Company | Contact | Country |
|---|---|---|
| Alfreds Futterkiste | Maria Anders | Germany |
| Centro comercial Moctezuma | Francisco Chang | Mexico |


The Coffee Connection Till
Serving hipsters since
2018
!
Customer Name:
Add Names
Cost:
Pay Cash!
Items
Cafe Latte: £4.75
Flat White: £4.75
Cappucino: £3.85
Single Espresso: £2.05
Double Espresso: £2.05
Americano: £3.75
Cortado: £4.55
Tea: £3.65
Choc Mudcake: £6.40
Choc Mousse: £8.20
Affogato: £14.80
Tiramisu: £11.40
Blueberry Muffin: £4.05
Chocolate Chip Muffin: £4.05
Muffin Of The Day: £4.55
Add To Cart
Cart
-------------
Clear Cart
Receipt
Next Customer
Enter Cash


Barry Scott
Reading, Berkshire, England
<EMAIL_ADDRESS>Paul F. Dubois<EMAIL_ADDRESS>Lawrence Livermore National Laboratory
Livermore, California, U.S.A.
PyCXX is designed to make it easier to extend Python with C++
PyCXX is a set of C++ facilities to make it easier to write Python extensions. The chief way in which PyCXX makes it easier to write Python extensions is that it greatly increases the probability that your program will not make a reference-counting error and will not have to continually check error returns from the Python C API. PyCXX integrates Python with C++ in these ways:
Download PyCXX from http://sourceforge.net/projects/cxx/.
The distribution layout is:
| Directory | Description |
|---|---|
| . | Makefile for Unix and Windows, Release documentation |
| ./CXX | Header files |
| ./Src | Source files |
| ./Doc | Documentation |
| ./Demo | Testing and Demonstartion files |
To use PyCXX you use its include files and add its source routines to your module.
Installation:
The header file CXX/config.h may need to be adjusted for the compiler you use. As of this writing, only a fairly obscure reference to part of the standard library needs this adjustment. Unlike prior releases, PyCXX now assumes namespace support and a standard C++ library.
All PyCXX assets are in namespace "Py". You need to include the Py:: prefix when referring to them, or include the statement:
using namespace Py;
Header file CXX_Objects.h requires adding file Src/cxxsupport.cxx to your module sources. CXX_Objects provides a set of wrapper classes that allow you access to most of the Python C API using a C++ notation that closely resembles Python. For example, this Python:
d = {} d["a"] = 1 d["b"] = 2 alist = d.keys() print alist
Can be written in C++:
Dict d; List alist; d["a"] = Int(1); d["b"] = Int(2); alist = d.keys(); std::cout << alist << std::endl;
You can optionally use the CXX/Extensions.hxx facility described later to define Python extension modules and extension objects.
The essential idea is that we avoid, as much as possible, programming with pointers to Python objects, that is, variables of type PyObject*. Instead, we use instances of a family of C++ classes that represent the usual Python objects. This family is easily extendible to include new kinds of Python objects.
For example, consider the case in which we wish to write a method, taking a single integer argument, that will create a Python dict and insert into it that the integer plus one under the key value. In C we might do that as follows:
static PyObject* mymodule_addvalue (PyObject* self, PyObject* args) { PyObject *d; PyObject* f; int k; PyArgs_ParseTuple(args, "i", &k); d = PyDict_New(); if (!d) return NULL; f = PyInt_NEW(k+1); if(!f) { Py_DECREF(d); /* have to get rid of d first */ return NULL; } if(PyDict_SetItemString(d, "value", f) == -1) { Py_DECREF(f); Py_DECREF(d); return NULL; } return d; }
If you have written a significant Python extension, this tedium looks all too familiar. The vast bulk of the coding is error checking and cleanup. Now compare the same thing written in C++ using CXX/Objects.hxx. The things with Python-like names (Int, Dict, Tuple) are from CXX/Objects.hxx.
static PyObject* mymodule_addvalue (PyObject* self, PyObject* pargs) { try { Tuple args(pargs); args.verify_length(1); Dict d; Int k = args[0]; d["value"] = k + 1; return new_reference_to(d); } catch (const PyException&) { return NULL; } }
If there are not the right number of arguments or the argument is not an integer, an exception is thrown. In this case we choose to catch it and convert it into a Python exception. The C++ exception handling mechanism takes care all the cleanup.
Note that the creation of the Int k got the first argument and verified that it is an Int.
Just to peek ahead, if you wrote this method in an ExtensionModule-derived module of your own, it would be a method and it could be written even more simply:
Object addvalue (Object & self, const Tuple & args) { args.verify_length(1); Dict d; Int k = args[0]; d["value"] = k + 1; return d; }
The basic concept of CXX/Objects.hxx is to create a wrapper around each PyObject * so that the reference counting can be done automatically, thus eliminating the most frequent source of errors. In addition, we can then add methods and operators so that Python objects can be manipulated in C++ much like you would in Python.
Each Object contains a PyObject * to which it owns a reference. When an Object is destroyed, it releases its ownership on the pointer. Since C++ calls the destructors on objects that are about to go out of scope, we are guaranteed that we will keep the reference counts right even if we unexpectedly leave a routine with an exception.
As a matter of philosophy, CXX/Objects.hxx prevents the creation of instances of its classes unless the instance will be a valid instance of its class. When an attempt is made to create an object that will not be valid, an exception is thrown.
Class Object represents the most general kind of Python object. The rest of the classes that represent Python objects inherit from it.
Object Type Int Float Long Complex Char Sequence -> SeqBase<T> String Tuple List Mapping -> MapBase<T> Dict Callable Module
There are several constructors for each of these classes. For example, you can create an Int from an integer as in
Int s(3)
However, you can also create an instance of one of these classes using any PyObject* or another Object. If the corresponding Python object does not actually have the type desired, an exception is thrown. This is accomplished as follows. Class Object defines a virtual function accepts:
virtual bool accepts(PyObject* p)
The base class version of accepts returns true for any pointer p except 0. This means we can create an Object using any PyObject *, or from any other Object. However, if we attempt to create an Int from a PyObject *, the overridding version of accepts in class Int will only accept pointers that correspond to Python ints. Therefore if we have a Tuple t and we wish to get the first element and be sure it is an Int, we do
Int first_element = t[0]
This will not only accomplish the goal of extracting the first element of the Tuple t, but it will ensure that the result is an Int. If not, an exception is thrown. The exception mechanism is discussed later.
Class Object serves as the base class for the other classes. Its default constructor constructs a Py_None, the unique object of Python type None. The interface to Object consists of a large number of methods corresponding to the operations that are defined for every Python object. In each case, the methods throw an exception if anything goes wrong.
There is no method corresponding to PyObject_SetItem with an arbitrary Python object as a key. Instead, create an instance of a more specific child of Object and use the appropriate facilities.
The comparison operators use the Python comparison function to compare values. The method is is available to test for absolute identity.
A conversion to standard library string type std::string is supplied using method as_string. Stream output of PyCXX Object instances uses this conversion, which in turn uses the Python object's str() representation.
All the numeric operators are defined on all possible combinations of Object, long, and double. These use the corresponding Python operators, and should the operation fail for some reason, an exception is thrown.
Often, PyObject * pointers are acquired from some function, particularly functions in the Python C API. If you wish to make an object from the pointer returned by such a function, you need to know if the function returns you an owned or unowned reference. Unowned references are unusual but there are some cases where unowned references are returned.
Usually, Object and its children acquire a new reference when constructed from a PyObject *. This is usually not the right behavior if the reference comes from one of the Python C API calls.
If p is an owned reference, you can add the boolean true as an extra argument in the creation routine, Object(p, true), or use the function asObject(p) which returns an Object created using the owned reference. For example, the routine PyString_FromString returns an owned reference to a Python string object. You could write:
Object w = asObject( PyString_FromString("my string") );
or using the constructor,
Object w( PyString_FromString("my string"), true );
In fact, you would never do this, since PyCXX has a class String and you can just say:
String w( "my string" );
Indeed, since most of the Python C API is similarly embodied in Object and its descendents, you probably will not use asObject all that often.
| Returns | Name(signature) | Comment |
|---|---|---|
Basic Methods |
||
| explicit | Object (PyObject* pyob=Py_None, bool owned=false) | Construct from pointer. |
| explicit | Object (const Object& ob) | Copycons; acquires an owned reference. |
| Object& | operator= (const Object& rhs) | Acquires an owned reference. |
| Object& | operator= (PyObject* rhsp) | Acquires an owned reference. |
| virtual | ~Object () | Releases the reference. |
| void | increment_reference_count() | Explicitly increment the count |
| void | decrement_reference_count() | Explicitly decrement count but not to zero |
| PyObject* | operator* () const | Lends the pointer |
| PyObject* | ptr () const | Lends the pointer |
| virtual bool | accepts (PyObject *pyob) const | Would assignment of pyob to this object succeed? |
| std::string | as_string() const | str() representation |
| Python API Interface | ||
| int | reference_count () const | reference count |
| Type | type () const | associated type object |
| String | str () const | str() representation |
| String | repr () const | repr () representation |
| bool | hasAttr (const std::string& s) const | hasattr(this, s) |
| Object | getAttr (const std::string& s) const | getattr(this, s) |
| Object | getItem (const Object& key) const | getitem(this, key) |
| long | hashValue () const | hash(this) |
| void | setAttr (const std::string& s, const Object& value) |
this.s = value |
| void | delAttr (const std::string& s) | del this.s |
| void | delItem (const Object& key) | del this[key] |
| bool | isCallable () const | does this have callable behavior? |
| bool | isList () const | is this a Python list? |
| bool | isMapping () const | does this have mapping behaviors? |
| bool | isNumeric () const | does this have numeric behaviors? |
| bool | isSequence () const | does this have sequence behaviors? |
| bool | isTrue () const | is this true in the Python sense? |
| bool | isType (const Type& t) const | is type(this) == t? |
| bool | isTuple() const | is this a Python tuple? |
| bool | isString() const | is this a Python string? |
| bool | isUnicode() const | is this a Python Unicode string? |
| bool | isDict() const | is this a Python dictionary? |
| Comparison Operators | ||
| bool | is(PyObject* pother) const | test for identity |
| bool | is(const Object& other) const | test for identity |
| bool | operator==(const Object& o2) const | Comparisons use Python cmp |
| bool | operator!=(const Object& o2) const | Comparisons use Python cmp |
| bool | operator>=(const Object& o2) const | Comparisons use Python cmp |
| bool | operator<=(const Object& o2) const | Comparisons use Python cmp |
| bool | operator<(const Object& o2) const | Comparisons use Python cmp |
| bool | operator>(const Object& o2) const | Comparisons use Python cmp |
Corresponding to each of the basic Python types is a class that inherits from Object. Here are the interfaces for those types. Each of them inherits from Object and therefore has all of the inherited methods listed for Object. Where a virtual function is overridden in a class, the name is underlined.
Class Type corresponds to Python type objects. There is no default constructor.
| Returns | Name and Signature | Comments |
|---|---|---|
| explicit | Type (PyObject* pyob, bool owned = false) | Constructor |
| explicit | Type (const Object& ob) | Constructor |
| explicit | Type(const Type& t) | Copycons |
| Type& | operator= (const Object& rhs) | Assignment |
| Type& | operator= (PyObject* rhsp) | Assignment |
| virtual bool | accepts (PyObject *pyob) const | Uses PyType_Check |
Class Int, derived publically from Object, corresponds to Python ints. Note that the latter correspond to C long ints. Class Int has an implicit user-defined conversion to long int. All constructors, on the other hand, are explicit. The default constructor creates a Python int zero.
| Returns | Name and Signature | Comments |
|---|---|---|
| explicit | Int (PyObject *pyob, bool owned= false, bool owned = false) | Constructor |
| explicit | Int (const Int& ob) | Constructor |
| explicit | Int (long v = 0L) | Construct from long |
| explicit | Int (int v) | Contruct from int |
| explicit | Int (const Object& ob) | Copycons |
| Int& | operator= (const Object& rhs) | Assignment |
| Int& | operator= (PyObject* rhsp) | Assignment |
| virtual bool | (PyObject *pyob) const | Based on PyInt_Check |
| long | operator long() const | Implicit conversion to long int |
| Int& | operator= (int v) | Assign from int |
| Int& | operator= (long v) | Assign from long |
Class Long, derived publically from Object, corresponds to Python type long. In Python, a long is an integer type of unlimited size, and is usually used for applications such as cryptography, not as a normal integer. Implicit conversions to both double and long are provided, although the latter may of course fail if the number is actually too big. All constructors are explicit. The default constructor produces a Python long zero.
| Returns | Name and Signature | Comments |
|---|---|---|
| explicit | Long (PyObject *pyob, bool owned = false) | Constructor |
| explicit | Long (const Int& ob) | Constructor |
| explicit | Long (long v = 0L) | Construct from long |
| explicit | Long (int v) | Contruct from int |
| explicit | Long (const Object& ob) | Copycons |
| Long& | operator= (const Object& rhs) | Assignment |
| Long& | operator= (PyObject* rhsp) | Assignment |
| virtual bool | (PyObject *pyob) const | Based on PyLong_Check |
| double | operator double() const | Implicit conversion to double |
| long | operator long() const | Implicit conversion to long |
| Long& | operator= (int v) | Assign from int |
| Long& | operator= (long v) | Assign from long |
Class Float corresponds to Python floats, which in turn correspond to C double. The default constructor produces the Python float 0.0.
| Returns | Name and Signature | Comments |
|---|---|---|
| explicit | Float (PyObject *pyob, bool owned = false) | Constructor |
| Float (const Float& f) | Construct from float | |
| explicit | Float (double v=0.0) | Construct from double |
| explicit | Float (const Object& ob) | Copycons |
| Float& | operator= (const Object& rhs) | Assignment |
| Float& | operator= (PyObject* rhsp) | Assignment |
| virtual bool | accepts (PyObject *pyob) const | Based on PyFloat_Check |
| double | operator double () const | Implicit conversion to double |
| Float& | operator= (double v) | Assign from double |
| Float& | operator= (int v) | Assign from int |
| Float& | operator= (long v) | Assign from long |
| Float& | operator= (const Int& iob) | Assign from Int |
PyCXX implements a quite sophisticated wrapper class for Python sequences. While every effort has been made to disguise the sophistication, it may pop up in the form of obscure compiler error messages, so in this documentation we will first detail normal usage and then discuss what is under the hood.
The basic idea is that we would like the subscript operator [] to work properly, and to be able to use STL-style iterators and STL algorithms across the elements of the sequence.
Sequences are implemented in terms of a templated base class, SeqBase<T>. The parameter T is the answer to the question, sequence of what? For Lists, for example, T is Object, because the most specific thing we know about an element of a List is simply that it is an Object. (Class List is defined below; it is a descendent of Object that holds a pointer to a Python list). For strings, T is Char, which is a wrapper in turn of Python strings whose length is one.
For convenience, the word Sequence is a typedef of SeqBase<Object>.
Suppose you are writing an extension module method that expects the first argument to be any kind of Python sequence, and you wish to return the length of that sequence. You might write:
static PyObject* my_module_seqlen (PyObject *self, PyObject* args) { try { Tuple t(args); // set up a Tuple pointing to the arguments. if(t.length() != 1) throw PyException("Incorrect number of arguments to seqlen."); Sequence s = t[0]; // get argument and be sure it is a sequence return new_reference_to(Int(s.length())); } catch(const PyException&) { return Py_Null; } }
As we will explain later, the try/catch structure converts any errors, such as the first argument not being a sequence, into a Python exception.
When a sequence is subscripted, the value returned is a special kind of object which serves as a proxy object. The general idea of proxy objects is discussed in Scott Meyers' book, "More Effective C++". Proxy objects are necessary because when one subscripts a sequence it is not clear whether the value is to be used or the location assigned to. Our proxy object is even more complicated than normal because a sequence reference such as s[i] is not a direct reference to the i'th object of s.
In normal use, you are not supposed to notice this magic going on behind your back. You write:
Object t; Sequence s; s[2] = t + s[1]
and here is what happens: s[1] returns a proxy object. Since there is no addition operator in Object that takes a proxy as an argument, the compiler decides to invoke an automatic conversion of the proxy to an Object, which returns the desired component of s. The addition takes place, and then there is an assignment operator in the proxy class created by the s[2], and that assignment operator stuffs the result into the 2 component of s.
It is possible to fool this mechanism and end up with a compiler failing to admit that a s[i] is an Object. If that happens, you can work around it by writing Object(s[i]), which makes the desired implicit conversion, explicit.
Each sequence class provides the following interface. The class seqref<T> is the proxy class. We omit the details of the iterator, const_iterator, and seqref<T> here. See CXX_Objects.h if necessary. The purpose of most of this interface is to satisfy requirements of the STL.
SeqBase<T> inherits from Object.
| Type | Name |
|---|---|
| typedef int | size_type |
| typedef seqref<T> | reference |
| typedef T | const_reference |
| typedef seqref<T>* | pointer |
| typedef int | difference_type |
| virtual size_type | max_size() const |
| virtual size_type | capacity() const; |
| virtual void | swap(SeqBase<T>& c); |
| virtual size_type | size () const; |
| explicit | SeqBase<T> (); |
| explicit | SeqBase<T> (PyObject* pyob, bool owned = false); |
| explicit | SeqBase<T> (const Object& ob); |
| SeqBase<T>& | operator= (const Object& rhs); |
| SeqBase<T>& | operator= (PyObject* rhsp); |
| virtual bool | accepts (PyObject *pyob) const; |
| size_type | length () const ; |
| const T | operator[](size_type index) const; |
| seqref<T> | operator[](size_type index); |
| virtual T | getItem (size_type i) const; |
| virtual void | setItem (size_type i, const T& ob); |
| SeqBase<T> | repeat (int count) const; |
| SeqBase<T> | concat (const SeqBase<T>& other) const ; |
| const T | front () const; |
| seqref<T> | front(); |
| const T | back () const; |
| seqref<T> | back(); |
| void | verify_length(size_type required_size); |
| void | verify_length(size_type min_size, size_type max_size); |
| class | iterator; |
| iterator | begin (); |
| iterator | end (); |
| class | const_iterator; |
| const_iterator | begin () const; |
| const_iterator | end () const; |
Any heir of class Object that has a sequence behavior should inherit from class SeqBase<T>, where T is specified as the type of object that represents the individual elements of the sequence. The requirements on T are that it has a constructor that takes a PyObject* as an argument, that it has a default constructor, a copy constructor, and an assignment operator. In short, any properly defined heir of Object will work.
Python strings are unusual in that they are immutable sequences of characters. However, there is no character type per se; rather, when subscripted strings return a string of length one. To simulate this, we define two classes Char and String. The Char class represents a Python string object of length one. The String class represents a Python string, and its elements make up a sequence of Char's.
The user interface for Char is limited. Unlike String, for example, it is not a sequence.
Char inherits from Object.
| Type | Name |
|---|---|
| explicit | Char (PyObject *pyob, bool owned = false) |
| Char (const Object& ob) | |
| Char (const std::string& v = "") | |
| Char (char v) | |
| Char (Py_UNICODE v) | |
| Char& | operator= (const std::string& v) |
| Char& | operator= (char v) |
| Char& | operator= (Py_UNICODE v) |
| Char& | operator= (std::basic_string |
| operator String() const | |
| operator std::string () const |
String inherits from SeqBase<Char>.
| Type | Name |
|---|---|
| explicit | String (PyObject *pyob, bool owned = false) |
| String (const Object& ob) | |
| String (const std::string& v = "") | |
| String (const std::string& v, const char *encoding, const char *error="strict") | |
| String (const char *s, const char *encoding, const char *error="strict") | |
| String (const char *s, int len, const char *encoding, const char *error="strict") | |
| String (const std::string& v, std::string::size_type vsize) | |
| String (const char* v) | |
| String& | operator= (const std::string& v) |
| std::string | operator std::string () const |
| String | encode( const char *encoding, const char *error="strict" ) |
| String | decode( const char *encoding, const char *error="strict" ) |
| std::string | as_std_string() const |
| unicodestring | as_unicodestring() const |
Class Tuple represents Python tuples. A Tuple is a Sequence. There are two kinds of constructors: one takes a PyObject* as usual, the other takes an integer number as an argument and returns a Tuple of that length, each component initialized to Py_None. The default constructor produces an empty Tuple.
Tuples are not immutable, but attempts to assign to their components will fail if the reference count is not 1. That is, it is safe to set the elements of a Tuple you have just made, but not thereafter.
Example: create a Tuple containing (1, 2, 4)
Tuple t(3) t[0] = Int(1) t[1] = Int(2) t[2] = Int(4)
Example: create a Tuple from a list:
Dict d ... Tuple t(d.keys())
Tuple inherits from Sequence.. Special run-time checks prevent modification if the reference count is greater than one.
| Type | Name | Comment |
|---|---|---|
| virtual void | setItem (int offset, const Object&ob) | setItem is overriden to handle tuples properly. |
| explicit | Tuple (PyObject *pyob, bool owned = false) | |
| Tuple (const Object& ob) | ||
| explicit | Tuple (int size = 0) | Create a tuple of the given size. Items initialize to Py_None. Default is an empty tuple. |
| explicit | Tuple (const Sequence& s) | Create a tuple from any sequence. |
| Tuple& | operator= (const Object& rhs) | |
| Tuple& | operator= (PyObject* rhsp) | |
| Tuple | getSlice (int i, int j) const | Equivalent to python's t[i:j] |
Class List represents a Python list, and the methods available faithfully reproduce the Python API for lists. A List is a Sequence.
List inherits from Sequence.
| Type | Name | Comment |
|---|---|---|
| explicit | List (PyObject *pyob, bool owned = false) | |
| List (const Object& ob) | ||
| List (int size = 0) | Create a list of the given size. Items initialized to Py_None. Default is an empty list. | |
| List (const Sequence& s) | Create a list from any sequence. | |
| List& | operator= (const Object& rhs) | |
| List& | operator= (PyObject* rhsp) | |
| List | getSlice (int i, int j) const | |
| void | setSlice (int i, int j, const Object& v) | |
| void | append (const Object& ob) | |
| void | insert (int i, const Object& ob) | |
| void | sort () | Sorts the list in place, using Python's member function. You can also use the STL sort function on any List instance. |
| void | reverse () | Reverses the list in place, using Python's member function. |
A class MapBase<T> is used as the base class for Python objects with a mapping behavior. The key behavior of this class is the ability to set and use items by subscripting with strings. A proxy class mapref<T> is defined to produce the correct behavior for both use and assignment.
For convenience, Mapping is a typedef for MapBase<Object>.
MapBase<T> inherits from Object. T should be chosen to reflect the kind of element returned by the mapping.
| Type | Name | Comment |
|---|---|---|
| T | operator[](const std::string& key) const | |
| mapref<T> | operator[](const std::string& key) | |
| int | length () const | Number of entries. |
| int | hasKey (const std::string& s) const | Is m[s] defined? |
| T | getItem (const std::string& s) const | m[s] |
| virtual void | setItem (const std::string& s, const Object& ob) | m[s] = ob |
| void | delItem (const std::string& s) | del m[s] |
| void | delItem (const Object& s) | |
| List | keys () const | A list of the keys. |
| List | values () const | A list of the values. |
| List | items () const | Each item is a key-value pair. |
Class Dict represents Python dictionarys. A Dict is a Mapping. Assignment to subscripts can be used to set the components.
Dict d d["Paul Dubois"] = "(925)-422-5426"
Dict inherits from MapBase<Object>.
| Type | Name | Comment |
|---|---|---|
| explicit | Dict (PyObject *pyob, bool owned = false) | |
| Dict (const Dict& ob) | ||
| Dict () | Creates an empty dictionary | |
| Dict& | operator= (const Object& rhs) | |
| Dict& | operator= (PyObject* rhsp) |
Class Callable provides an interface to those Python objects that support a call method. Class Module holds a pointer to a module. If you want to create an extension module, however, see the extension facility. There is a large set of numeric operators.
| Type | Name | Comment |
|---|---|---|
| explicit | Callable (PyObject *pyob, bool owned = false) | |
| Callable& | operator= (const Object& rhs) | |
| Callable& | operator= (PyObject* rhsp) | |
| Object | apply(const Tuple& args) const | Call the object with the given arguments |
| Object | apply(PyObject* pargs = 0) const | Call the object with args as the arguments. Checks that pargs is a tuple. |
| Type | Name | Comment |
|---|---|---|
| explicit | Module (PyObject* pyob, bool owned = false) | |
| explicit | Module (const std::string name) | Construct from name of module; does the import if needed. |
| Module (const Module& ob) | Copy constructor | |
| Module& | operator= (const Object& rhs) | Assignment |
| Module& | operator= (PyObject* rhsp) | Assignment |
Unary operators for plus and minus, and binary operators +, -, *, /, and % are defined for pairs of objects and for objects with scalar integers or doubles (in either order). Functions abs(ob) and coerce(o1, o2) are also defined.
The signature for coerce is:
inline std::pair<Object,Object> coerce(const Object& a, const Object& b)
Unlike the C API function, this simply returns the pair after coercion.
Any object can be printed using stream I/O, using std::ostream& operator<< (std::ostream& os, const Object& ob). The object's str() representation is converted to a standard string which is passed to std::ostream& operator<< (std::ostream& os, const std::string&).
The Python exception facility and the C++ exception facility can be merged via the use of try/catch blocks in the bodies of extension objects and module functions.
A set of classes is provided. Each is derived from class Exception, and represents a particular sort of Python exception, such as IndexError, RuntimeError, ValueError. Each of them (other than Exception) has a constructor which takes an explanatory string as an argument, and is used in a throw statement such as:
throw IndexError("Index too large in MyObject access.");
If in using a routine from the Python API, you discover that it has returned a NULL indicating an error, then Python has already set the error message. In that case you merely throw Exception.
The exception hierarchy mirrors the Python exception hierarchy. The concrete exception classes are shown here.
| Type | Interface for class Exception |
|---|---|
| explicit | Exception() |
| Exception (const std::string& reason) | |
| Exception (PyObject* exception, const std::string& reason) | |
| void | clear() |
| Constructors for other children of class Exception | |
| TypeError (const std::string& reason) | |
| IndexError (const std::string& reason) | |
| AttributeError (const std::string& reason) | |
| NameError (const std::string& reason) | |
| RuntimeError (const std::string& reason) | |
| SystemError (const std::string& reason) | |
| KeyError (const std::string& reason) | |
| ValueError (const std::string& reason) | |
| OverflowError (const std::string& reason) | |
| ZeroDivisionError (const std::string& reason) | |
| MemoryError (const std::string& reason) | |
| SystemExit (const std::string& reason) |
The exception facility allows you to integrate the C++ and Python exception mechanisms. To do this, you must use the style described below when writing module methods in the old C style.
Note: If using the ExtensionModule or PythonExtension mechanisms described below, the method handlers include exception handling so that you only need to use exceptions explicitly in unusual cases.
When writing an extension module method, you can use the following boilerplate. Any exceptions caused by the Python API or PyCXX itself will be converted into a Python exception. Note that Exception is the most general of the exceptions listed above, and therefore this one catch clause will serve to catch all of them. You may wish to catch other exceptions, not in the Exception family, in the same way. If so, you need to make sure you set the error in Python before returning.
static PyObject * some_module_method(PyObject* self, PyObject* args) { Tuple a( args ); // we know args is a Tuple try { ...calculate something from a... return ...something, usually of the form new_reference_to(some Object); } catch( const Exception& ) { //Exception caught, passing it on to Python return None(); } }
If you anticipate that an Exception may be thrown and wish to recover from it, change the catch phrase to set a reference to an Exception, and use the method clear() from class Exception to clear it.:
catch( Exception& e ) { e.clear(); ...now decide what to do about it... }
CXX/Extensions.hxx provides facilities for:
These facilities use CXX/Objects.hxx and its support file cxxsupport.cxx.
If you use CXX/Extensions.hxx you must also include source files cxxextensions.c and cxx_extensions.cxx
The usual method of creating a Python extension module is to declare and initialize its method table in C. This requires knowledge of the correct form for the table and the order in which entries are to be made into it, and requires casts to get everything to compile without warning. The PyCXX header file CXX/Extensions.h offers a simpler method. Here is a sample usage, in which a module named "example" is created. Note that two details are necessary:
To create an extension module, you inherit from class ExtensionModule templated on yourself: In the constructor, you make calls to register methods of this class with Python as extension module methods. In this example, two methods are added (this is a simplified form of the example in Demo/example.cxx):
class example_module : public ExtensionModule<example_module> { public: example_module() : ExtensionModule<example_module>( "example" ) { add_varargs_method("sum", &example_module::ex_sum, "sum(arglist) = sum of arguments"); add_varargs_method("test", &example_module::ex_test, "test(arglist) runs a test suite"); initialize( "documentation for the example module" ); } virtual ~example_module() {} private: Object ex_sum(const Tuple &a) { ... } Object ex_test(const Tuple &a) { ... } };
To initialize the extension, you just instantiate one static instance (static so it does not destroy itself!):
void initexample() { static example_module* example = new example_module; }
The methods can be written to take Tuples as arguments and return Objects.  So, for example, the implementation of ex_sum might be:
Object ex_sum (const Tuple &a) { Float f(0.0); for( int i = 0; i < a.length(); i++ ) { Float g(a[i]); f = f + g; } return f; }
class ExtensionModule contains methods to return itself as a Module object, or to return its dictionary.
| Type | Name | Comment |
|---|---|---|
| explicit | ExtensionModule (char* name) | Create an extension module named "name" |
| virtual | ~ExtensionModule () | Destructor |
| Dict | moduleDictionary() const | Returns the module dictionary; module must be initialized. |
| Module | module() const | This module as a Module. |
| void | add_varargs_method (char *name, method_varargs_function_t method, char *documentation="") | Add a method to the module. |
| void | add_keyword_method (char *name, method_keyword_function_t method, char *documentation="" | Add a method that takes keywords |
| void | initialize() (protected, call from constructor) | Initialize the module once all methods have been added. |
The signatures above are:
typedef Object (T::*method_varargs_function_t)( const Tuple &args ); typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws );
That is, the methods take a Tuple or a Tuple and a Dict, and return an Object. The example below has an & in front of the name of the method; we found one compiler that needed this.
One of the great things about Python is the way you can create your own object types and have Python welcome them as first-class citizens. Unfortunately, part of the way you have to do this is not great. Key to the process is the creation of a Python "type object". All instances of this type must share a reference to this one unique type object. The type object itself has a multitude of "slots" into which the addresses of functions can be added in order to give the object the desired behavior.
Creating extension objects is of course harder since you must specify how the object behaves and give it methods. This is shown in some detail in the example range.h and range.cxx, with the test routine rangetest.cxx, in directory Demo. If you have never created a Python extension before, you should read the Extension manual first and be very familiar with Python's "special class methods". Then what follows will make more sense.
The basic idea is to inherit from PythonExtension templated on your self
class MyObject: public PythonExtension<MyObject> {...}
As a consequence:
Here is a brief overview. You create a class that inherits from PythonExtension templated upon itself. You override various methods from PythonExtension to implement behaviors, such as getattr, sequence_item, etc. You can also add methods to the object that are usable from Python using a similar scheme as for module methods above.
One of the consequences of inheriting from PythonExtension is that you are inheriting from PyObject itself. So your class is-a PyObject and instances of it can be passed to the Python C API. Note: this example uses the namespace feature of PyCXX.
Hint: You can avoid needing to specify the Py:: prefix if you include the C++ statement using Py; at the top of your files.
class range: public Py::PythonExtension<range> { public: ... constructors, data, etc. ... methods not callable from Python // initializer, see below static void init_type(); // override functions from PythonExtension virtual Py::Object repr(); virtual Py::Object getattr( const char *name ); virtual int sequence_length(); virtual Py::Object sequence_item( int i ); virtual Py::Object sequence_concat( const Py::Object &j ); virtual Py::Object sequence_slice( int i, int j ); // define python methods of this object Py::Object amethod (const Py::Tuple& args); Py::Object value (const Py::Tuple& args); Py::Object assign (const Py::Tuple& args); };
To initialize the type we provide a static method that we can call from some module's initializer. We set the name, doc string, and indicate which behaviors range objects support. Then we adds the methods.
void range::init_type() { behaviors().name("range"); behaviors().doc("range objects: start, stop, step"); behaviors().supportRepr(); behaviors().supportGetattr(); behaviors().supportSequenceType(); add_varargs_method("amethod", &range::amethod, "demonstrate how to document amethod"); add_varargs_method("assign", &range::assign); add_varargs_method("value", &range::value); }
Do not forget to add the call range::init_type() to some module's init function. You will want a method in some module that can create range objects, too.
Your extension class T inherits PythonExtension<T>.
| Type | Name | Comment |
|---|---|---|
| virtual | ~PythonExtension<T>() | Destructor |
| PyTypeObject* | type_object() const | Returns the object type object. |
| int | check (PyObject* p) | Is p a T? |
| Protected | ||
| void | add_varargs_method (char *name, method_keyword_function_t method, char *documentation="" | Add a method that takes arguments |
| void | add_keyword_method (char *name, method_keyword_function_t method, char *documentation="" | Add a method that takes keywords |
| static PythonType& | behaviors() | The type object |
| void | initialize() (protected, call from constructor) | Initialize the module once all methods have been added. |
As before the signatures for the methods are Object mymethod(const Tuple& args) and Object mykeywordmethod (const Tuple& args, const Dict& keys). In this case, the methods must be methods of T.
To set the behaviors of the object you override some or all of these methods from PythonExtension<T>:
virtual int print( FILE *, int ); virtual Object getattr( const char * ); virtual int setattr( const char *, const Object & ); virtual Object getattro( const Object & ); virtual int setattro( const Object &, const Object & ); virtual int compare( const Object & ); virtual int rich_compare( const Object &, int op ); virtual Object repr(); virtual Object str(); virtual long hash(); virtual Object call( const Object &, const Object & ); // Sequence methods virtual int sequence_length(); virtual Object sequence_concat( const Object & ); virtual Object sequence_repeat( int ); virtual Object sequence_item( int ); virtual Object sequence_slice( int, int ); virtual int sequence_ass_item( int, const Object & ); virtual int sequence_ass_slice( int, int, const Object & ); // Mapping virtual int mapping_length(); virtual Object mapping_subscript( const Object & ); virtual int mapping_ass_subscript( const Object &, const Object & ); // Number virtual int number_nonzero(); virtual Object number_negative(); virtual Object number_positive(); virtual Object number_absolute(); virtual Object number_invert(); virtual Object number_int(); virtual Object number_float(); virtual Object number_long(); virtual Object number_oct(); virtual Object number_hex(); virtual Object number_add( const Object & ); virtual Object number_subtract( const Object & ); virtual Object number_multiply( const Object & ); virtual Object number_divide( const Object & ); virtual Object number_remainder( const Object & ); virtual Object number_divmod( const Object & ); virtual Object number_lshift( const Object & ); virtual Object number_rshift( const Object & ); virtual Object number_and( const Object & ); virtual Object number_xor( const Object & ); virtual Object number_or( const Object & ); virtual Object number_power( const Object &, const Object & ); // Buffer virtual int buffer_getreadbuffer( int, void** ); virtual int buffer_getwritebuffer( int, void** ); virtual int buffer_getsegcount( int* );
Note that dealloc is not one of the functions you can override. That is what your destructor is for. As noted below, dealloc behavior is provided for you by PythonExtension.
To initialize your type, supply a static public member function that can be called from the extension module. In that function, obtain the PythonType object by calling behaviors() and apply appropriate "support" methods from PythonType to turn on the support for that behavior or set of behaviors.
void supportPrint(void); void supportGetattr(void); void supportSetattr(void); void supportGetattro(void); void supportSetattro(void); void supportCompare(void); void supportRichCompare(void); void supportRepr(void); void supportStr(void); void supportHash(void); void supportCall(void); void supportSequenceType(void); void supportMappingType(void); void supportNumberType(void); void supportBufferType(void);
Then call add_varargs_method or add_keyword_method to add any methods desired to the object.
Normal Python objects exist only on the heap. That is unfortunate, as object creation and destruction can be relatively expensive. Class PythonExtension allows creation of both local and heap-based objects.
If an extension object is created using operator new, as in:
range* my_r_ref = new range(1, 20, 3)
then the entity my_r_ref can be thought of as "owning" the reference created in the new object. Thus, the object will never have a reference count of zero. If the creator wishes to delete this object, they should either make sure the reference count is 1 and then do delete my_r_ref, or decrement the reference with Py_DECREF(my_r_ref).
Should my_r_ref give up ownership by being used in an Object constructor, all will still be well. When the Object goes out of scope its destructor will be called, and that will decrement the reference count, which in turn will trigger the special dealloc routine that calls the destructor and deletes the pointer.
If the object is created with automatic scope, as in:
range my_r(1, 20, 3)
then my_r can be thought of as owning the reference, and when my_r goes out of scope the object will be destroyed. Of course, care must be taken not to have kept any permanent reference to this object. Fortunately, in the case of an exception, the C++ exception facility will call the destructor of my_r.
The Demo directory of the distribution contains an extensive example of how to use many of the facilities in PyCXX. It also serves as a test routine. This test is not completely exhaustive but does excercise much of the facility.
Thank you to Geoffrey Furnish for patiently teaching me the finer points of C++ and its template facility, and his critique of PyCXX in particular. With version 4 I welcome Barry Scott as co-author. -- Paul Dubois


Health advisory issued after wastewater overflow in Clover Point Park area
by Cindy E. HarnettHeavy rain resulted in a stormwater and wastewater overflow along some shorelines in Greater Victoria on Sunday afternoon, says the Capital Regional District.
The area affected is near Clover Point Park, between Cook Street and Hollywood Place in Victoria.
Residents are advised to avoid going in the water along the affected shorelines, as the wastewater could pose a health risk.
Public-health advisory signs will be posted at beaches in the affected area until sample results indicate levels of the enterococci bacteria are below the recreational limit.
For updates, go to crd.bc.ca.


Pure Webcomponents Presentation Framework
web-presentation
Native, fast, extendable
..and only one file to import


Italy put nine past Armenia to maintain perfect record in Euro 2020 qualifying
Ciro Immobile and Nicolo Zaniolo both scored twice.
Italy finished their Euro 2020 qualifying campaign with a 100 per cent record from 10 games after thumping Armenia 9-1 in Palermo.
Ciro Immobile and Nicolo Zaniolo both scored twice as the Azzurri racked up an 11th straight win despite a much-changed starting line-up under Roberto Mancini.
Immobile and Zaniolo were among those promoted to the side after Friday’s 3-0 win in Bosnia and they delivered in style against their lowly opponents.
Edgar Babayan had missed a good chance for Armenia in the opening minutes before Immobile nodded the Italians in front from a Federico Chiesa free-kick.
Almost immediately after the re-start, the home side doubled their lead when Immobile played in Zaniolo, who beat Armenian keeper Aram Hayrapetyan to net his first senior international goal.
Chiesa and Immobile both came close for the Italians but Armenia should have reduced the deficit through Aleksandre Karapetyan, who pounced on a poor back-pass but hit the bar.
Nicolo Barella got on the end of a threaded through-ball from Leonardo Bonucci to make it 3-0 before Immobile sprung the offside trap to strike Italy’s fourth with 33 minutes gone.
Immobile might have wrapped up the first period with a hat-trick when his shot clipped the post in first-half injury time, while Chiesa also hit the woodwork after the break.
Zaniolo grabbed his second just past the hour mark and Alessio Romagnoli deflected home Italy’s sixth goal of the night with 72 minutes on the clock.
Jorginho added the seventh from the spot after a trip in the box, then Bologna’s Riccardo Orsolini marked his senior debut with a goal when he headed home in the 75th minute.
Babayan fired a brilliant consolation for Armenia from outside the box in the 79th minute but Chiesa finally secured his first senior goal two minutes later when he headed home from close range.


If you are looking for consultants that are experienced, easy going and spiced up with a strong focus on productivity, then you have come to the right place!
Find Out MoreWith 13 years of software industry experience both in consultant and product development environments. Lista branscher du varit aktiv i: Industrial Automation, E-commerce, Safety, Internet Connectivity, Distributed systems, Medical Technology, Healthcare
How can we help?C#, VB.NET, C++ / CLI, Desktop, Mobile, Backend.
Improvements in existing systems, support when designing new features or complete design from scratch.
Mapping of data between systems, communication and hardware interfaces. Everything needs to work together.
There refactoring of legacy system. eliminate code smell by refactoring and avoid technical debt.
Software is never complete. After deployment you have to plan for work such as fixing bugs, respond to customer feedback and eliminate technical debt.
Scale your development process from Kanban and SCRUM to enterprise models such as SAFe and LeSS. What are your needs?
Ready to start your next project with us? That's great! Give us a call or send us an email and we will get back to you as soon as possible!
123-456-6789


Hamsters are known as pocket pets, and are small enough for a child to carry with ease. Their size makes them portable enough to accompany you wherever you go. Make sure to keep your hamster secure when you carry her. If you drop her while you stand or walk, she could break a leg. Keep a good hold on her. Hamsters are excellent escape artists
Hamsters are speedy, curious and energetic, and offer tons of entertainment. You can sit beside the cage, and watch your hamster at work and play as she burrows and climbs.
You don't need a huge yard or a nearby park for your tiny pal to romp in. You won't need a roomy crate or doghouse, either. Hamster habitats come in many sizes and you can buy one that fits your living space. Make sure your pet has space to explore and climb. Some plastic habitats have movable tubes that can be attached to extend the habitat's space.
Watching your hamster go about his business in his habitat can be very entertaining, but you may also want to take him out of his cage. Here are a few helpful tips to keep him safe.
Your hamster will do best in a cage larger than 600 square inches, although 450 square inches or 30 inches by 15 inches is the minimum. It should also be more than 12 inches tall so as to be able to fir an adequately sized wheel, 10-12 inches for Syrians and 8 inches for Dwarfs. A glass aquarium (as long as it meets the minimum floor space) is a great home for a hamster. The disadvantage is the lack of ventilation, so make sure the lid wire mesh to allow for air movement. An IKEA Detolf is an excellent choice too. Alternatively, the "cat tray with a wire top" type of hamster cage do have good natural ventilation. Make sure your cage is not in direct sunlight as your hamster could overheat due to the bright rays magnifying on the aquarium glass. Unless they're second hand, aquariums can be expensive.
Make sure there is plenty of ventilation.  Make sure to find a place that is quiet and free of any other household pets such as dogs and cats. This will reduce the stress of your pet hamster. At no point should you let your dogs or cats interact with your hamster
Provide your hamster with enough food each day to fill both cheeks, approximately 15g (1/2oz) for a Syrian hamster or 8g (1/4oz) for a Dwarf hamster. Make sure you provide fresh food in their bowl every day. Your hamster is a hoarder, so it'll keep private stashes. Removing these stashes can be very stressful, so if you are worried about the quality of their stored food, remove it and replace it with fresh food exactly where your hamster had it. Choose an earthenware or metal dish for their food. This is the best type of feeding bowl as your hamster will simply chew through a plastic one.


BY EDWIN JAHIEL
RUN LOLA RUN (LOLA RENNT) (Germany, 1998) *** Written and directed by Tom Tykwer. Photography, Frank Griebe. Editing, Mathilde Bonnefoy. Set design, Alexander Manasse. Music, Tom Tykwer, Johnny Klimek, Reimhold Heil. Animation sequences, Gil Alkabetz. Cast: Franka Potente (Lola), Moritz Bleibtreu (Manni), Herbert Knaup (Lola's father), Armin Rohde (Mr. Schuster), Joachim Krol ( the tramp Norbert von Au), Nina Petri (Mrs. Hansen), Heino Ferch (Ronnie). A Sony Pictures Classics release. 81 minutes. R (some merely "cartoonish" violence).
Overall applauded (but there are some naysayers too), Run Lola Run was probably made when its author was 32. Tom Tykwer had worked in TV, and in the realm of features had co-written a script, and wrote and directed two well received movies. Whether or not he'll prove to have been a "wunderkind" will depend on how much of his past output we can see (an unlikely occurrence) and what he will offer us next.
RLR is, at the very least, an interesting novelty, an unclassifiable work which is, above all, a stylistic exercise. The place is Berlin, though not identified as such and with no landmarks identifiable by strangers. Twenty-something Manni, a small-time courier for powerful mobsters boy is doing nicely and hopes to be promoted. But then the unexpected happens. Having delivered some goods to a buyer, and received 100,000 Deutschmarks (at this writing $ 52,356), he leaves his plastic bag in the subway when he makes a hurried exit to evade ticket inspectors. (OK, we all know that one always should keeps holding such loot with clenched fingers, but the film, being a fantasy, makes suspension of disbelief easy). If Manni returns empty-handed, the top mobster will doubtlessly kill him.
The panicked, hysterical young man phones his girlfriend Lola who asks him to wait 20 minutes until she gets there with the money -- which she does not have but somehow will get. She leaves her home, starts running, and runs and runs and runs. She's in great physical form, but see above the part about suspension of disbelief. This also applies to the ground she covers in just 20 minutes.
Manni is waiting for her outside a supermarket, which he said he would rob if Lola didn't get there on time. We keep track of this on a large clock which at the start showed 20 minutes to 12, and gradually, inexorably, suspensefully closes in on the fatal hour of12. This is High Noon, Germanicized with a twist!
It's all over in 20 minutes. Which leaves us 60 more of film. What the director does with them is to start Scenario One all over again, work in--with meticulous and unpredictable spontaneity--small variations, increase them to larger ones. Then he then backtracks and ends up with a different ending. The same goes for the 20-minute Scenario Three.
If I am cryptic it is that giving details, or even the main lines of the story (-ries) would be a killjoy. Especially since the movie's maker uses a full array of visual (and sound) tricks, from cartoons that connect to the action to split-screen, to pixillation, still shots, varying speeds, video, etc.
Lola in the running (and the stopping) process discovers a number of new things, mainly about her banker father and about herself. Again, I'll be cagey on the subject.
The Berlin of the film seems to be a sparsely populated, minor traffic city, which brought to my mind the title of the EricWolfgang Korngold opera The Dead City. I am guessing that the film must have been on Sundays or holidays. The relative emptiness of the sets makes it easy to keep track of Lola. Better yet, she can be always spotted by her distinctive, punkish hair painted flaming red-orange. The device is essentially similar to Haskell Wexler's, who made the classic Medium Cool (1969), a tour-de-force which dealt with the actual riots during the famous 1968 Democratic Convention in Chicago. Using a great deal of documentary footage, it inserted Wexler's actors in the streets and the crowds. For the audience to identify immediately Verna Bloom, Haskell had her wear a bright yellow dress that always stood out.
How much of a love story RLR may be does not get pictured by overt sentiments. There is just one small interlude of the lovers talking in bed. Otherwise, it is the extremely kinetic nature of the film plus the fact that Lola will do anything to save Manni.
Humor has always been an iffy aspect of Teutonic cinema. It does exist here however, but in indirect and/or played-down ways which do not get into the cuteness or broad effects that we find in much of American films these days. The funniest gag may be of Lola stepping out of a bank with a stash of stolen money and facing a regiment of heavily armed police. She is taken for a customer and taken out of harm's way by solicitous lawmen. And the last line in the movie, spoken by Manni, is deliciously ironical.
RLR, beyond showing the fickle finger of fate, has no real depth, carries no significant dialogue, no realistic or symbolic weight. But it is fresh and inventive, has a good matching musical score, excellent camera work, original editing (that's what makes the movie), and a fine musical commentary. It has avoided such smart-aleck shoals as pedantry, pretentiousness, pseudo-philosophy, pseudo-populism, and so on. On the surface, it is a light-weight job that could baffle audiences partial to well-made, well-told narratives. But it's also very clever.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


initialize |iˈniSHəˌlīz| – set to the value or put in the condition appropriate to the start of an operation
Use these base styles for body, typography, buttons, and tables in combination with Normalize CSS and other libraries like Basscss or Tachyons to quickly build out sites without the bloat of larger CSS frameworks.
GitHubTypography
Hello 1
Hello 2
Hello 3
Hello 4
Hello 5
Hello 6
- Two
- Four
- Eight
- Sixteen
- Thirty-Two
- Two
- Four
- Eight
- Sixteen
- Thirty-Two
This is a blockquote
This is some preformatted text.
This is a code
tag and a samp tag.
Buttons
Tables
| Animal | Sound |
|---|---|
| Cat | Meow |
| Dog | Woof |
| Cow | Moo |


“Science has produced such powerful weapons that in a war between great powers there would be neither victor nor vanquished. Both would be overwhelmed in destruction.”
At the heart of the United Nations is the General Assembly and at MSIT MUN 2016, we will be simulating one of the principal committees of the General Assembly, DISEC, also known as the First Committee, which focuses mostly on matters that deal with conflict prevention, disarmament and international security. Since the beginning of international cooperation in maritime security, the intertwining of piracy and maritime terrorism has been identified as a substantial risk for global markets, understanding that much of the world’s energy and cargoes being shipped through pirate-infested regions. Keeping this in mind, at MSITMUN’16, delegates will be required to push their skills of negotiation and to ultimately balance international cooperation with their own national interest to make this world a more peaceful and secure place!
“Human rights are women’s rights, and women’s rights are human rights.”
Only few know of the great impact the United Nations Human Rights Council has had in the promotion of international cooperation. It is not only the watchdog of the International Covenant on Civil and Political Rights, but also one of the key diplomatic forums working towards the universalization of Human Rights. The Universal Declaration of Human Rights establishes the right of women and children to equality as one of its unequivocal right and the end of the twentieth century saw an exponential development of Women’s rights by visionary and powerful global agreements. At MSITMUN’16, we invite you to evaluate this progress, to identify new challenges, set global standards and formulate concrete policies to promote gender equality and advancement of women worldwide.
“Human rights are women’s rights, and women’s rights are human rights.”
Lok Sabha is the by-product of the mandate of the populaces in the form of elections and universal adult suffrage. It serves as the central legislative body of the Indian polity and has seen a combination of both, vociferous and reticent speakers while retaining its position of being the primary platform for debate and discussion on issues of national importance. It has often been demeaned by the anarchist antics of the political class, however, at MSITMUN, we aim to simulate the Lok Sabha which enshrines cooperation rather than just confrontation. On a real note, this MUN will try to simulate the essence of our most esteemed body, which includes its content and its countenance. With a mandate of about 545 members we bring to you our own Indian platform: The Lok Sabha.
"Some people believe football is a matter of life and death, I can assure you it is much, much more important than that." - Bill Shankly.
The fifth committee to be simulated at the MSITMUN’16 is The European Club Association, which is a body representing the interests of association football clubs in UEFA. The rules of the game of football have not changed as massively over the last 140 years, as the spirit of the game has. The Spirit of the Game is an emphasis on sportsmanship, fun, respect-for-all and quality of play. At MSITMUN'16, we invite you to celebrate the spirit of the beautiful game as it has never been done before!
The third committee to be stimulated at MSITMUN is the North Atlantic Treaty Organization.
NATO is an intergovernmental military alliance based on the North Atlantic Treaty, which promotes democratic values and encourages consultation and cooperation on security issues to build trust and, in the long run, prevent conflict. If diplomatic efforts fail, it has the military capacity needed to undertake crisis-management operations, which are carried out under Article 5 of the Washington Treaty, invoked only once post the 9/11 attacks. What makes the NATO a successful body is the existence of a “NATO decision”, which is the expression of the collective will of all 28 member countries since all decisions are taken by consensus.
Dear Delegates,
We are honoured in inviting you to the inaugural edition of Maharaja Surajmal Institute of Technology Model United Nations, to be held on the 13th and 14th of August 2016 at the MSIT Campus at MSITMUN ‘16. We aim to provide delegates with a challenging experience of negotiation and diplomacy by assuming the roles of UN representatives and members of other international decision-making bodies. Delegates from all over the country are invited to converge to confront and debate issues of international importance. MSITMUN expects to promote not just simple public speaking or a sense of international relations, but also skills such as diplomacy, public speaking, cooperation, negotiation, and compromise. A variety of committees and agendas will ensure engaging and thought-provoking experience for each and every delegate, ranging from the European Club Association to the United Nations General Assembly to address some of the most important issues of our time."
Whether you have attended a Model United Nations Conference before or considering participating for the first time, we strongly encourage you to attend the conference to experience how Debate and Knowledge Sharing help in finding solutions for contemporary pressing issues, moreover how the aforementioned qualities bring change in how we think and look at those issues. MSITMUN ‘16 is an exciting opportunity to showcase your debating and negotiating skills, and we hope that you will choose to take part in it.
Quoting Desmond Tutu, "Don't raise your voice, improve your argument”, we must collectively think of improving our ability to reason and argue, and to put up a better fight for the cause"
Maharaja Surajmal Institute of Technology is an AICTE approved Institute under GGSIP University and is located in the Institutional area of Janakpuri, New Delhi.
Constantly ranked amongst the top engineering college in Delhi NCR, Maharaja Surajmal Institute’s campus comprises of well equipped fully air-conditioned laboratories and a well-stocked fully computerized library which provides an invigorating ambience and permits holistic development of students.


Scrollspy demo using a navigation bar
body
Attributes
data-spy="scroll"
data-target="#scrollspy-demo"
data-offset="56"
(⇒ Note 1 )nav.navbar.fixed-top.navbar-light
Attributes
id="scrollspy-demo"
style="background: rgba(222,222,222,0.6);"
(⇒ Note 2 )Scrollspy demo (1)
(see Navbar - brand )ul.nav.nav-pills
(see Navbar - nav )
div.container
Attribute
id="{position-id}"
to the tracking targete elementsdata-offset="56"
is the height of the navigation bar (px). As this page uses a fixed-top bar, scroll caluculation should be adjusted to set the origin of scroll tracking to just beneath the bar.iframe
). This demo uses a translucent navigation bar as compromise.Below are dummy scrolling contents. Each heading have a specific id="{position-id}"
for scroll tracking.


You've failed! Want to try again or submit your highscore?
Try to click all the balloons to get to the top of the highscore!
Collect special balloons for cool effects!

This game was written in Javascript by max1220(github) and Befrog(github).
All graphics were created in mspaint, audio files were created in audacity.


Date: {{event.date }}
Time : {{event.s_time }} until {{event.e_time }}
{{event.description }}
{% for time_block in time_blocks %}
{% include '/partials/time_block_show.html' %}
{% endfor %}
{% include '/partials/time_block_new.html' %}
{% endblock %}


President
Mr. Chales Vincent Cabarles
The highest governing student body for elementary in
Colegio de San Pedro
The CDSP Supreme Pupil Government is the highest duly constituted student government of the elementary department which initiates student activities geared towards the holistic development of its student members. As the highest student government in CDSP, the Supreme Pupil Government is at the forefront of promoting and advancing student rights and welfare. It has slated a range of programs, initiatives and advocacies that do not merely redound to the welfare of the Students of CDSP, but would also impact to the overall well-being of the community and the society in general.
This is our current CDSP SSG officers for 2020-2021


SARS-CoV- plasma SARS-CoV spike RBD OpenUrl protein mice antibody Figure samples patients (p-value binding two-tailed CrossRef coronavirus ectodomain infected responses virus t-test, human immunized response <; cross-reactivity domain Hong PBS SARS-CoV--infected antibodies e-, Abstract cross-reactive infection protein, sample FREE Kong SARS Text mean peptide SARS-CoV-infected Science healthy patients. purified receptor B). Binding ELISA SARS-CoV, SARS-CoV. University Wang, cleavage fusion influenza neutralizing non-neutralizing novel site, using vaccine viruses Huang, J.A. Med Nat SARS-CoV-. Yang, Yu, Zhang, activity analyzed autologous collected compared conserved coronaviruses day disease epitopes measured monoclonal mutations observed outbreak protective reactivity sequence study (HR), Black C-terminal Chen, Dashed ELISA. Graham, H.L., Lee, Li, Mouse N-terminal Nature Neutralization S). Vero Zhu, activities assay bioRxiv calculated cells coated common cross-neutralization cross-protective detected detection diluted glycoprotein heparin heptad indicate indicated. limit. line lines lower measured. mice, neutralization new plates proteins reacted recently receptor-binding recombinant repeat reported represents respiratory results serological shown. signal standard t-test) target tested testing triplicate used values virus.


some macros, and typedef's for better source maintain / readable.
More...
#include <stdint.h>
Go to the source code of this file.
|
| #define | FPC_DLLFUNC(x, y) _$dll$laz_ ## y ## $ ## x |
| | FPC produce prefix code for each DLL class export; This macro hold proper code for maintain / readable. More...
|
| |
| #define | FPC_BEGIN { |
| | This macro simple define the begin of an C scope. More...
|
| |
| #define | FPC_END } |
| | This macro simple define the end of an C scope. More...
|
| |
| #define | START_MANGLE extern "C" { |
| | This macro simple define the begin of an C++ de-mangle scope It is developer desire beatifuier. More...
|
| |
| #define | END_MANGLE }; |
| | This macro simple define the end of an C++ de-mangle scope It is developer desire beatifuier. More...
|
| |
| #define | START_CRT_NS namespace LazCRT { |
| | This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazCRT)
It is developer desire beatifuier. More...
|
| |
| #define | END_CRT_NS } |
| | This macro simple define the end of an C++ namespace scope. More...
|
| |
| #define | START_RTL_NS namespace LazVCL { |
| | This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazRTL)
It is developer desire beatifuier. More...
|
| |
| #define | END_RTL_NS } |
| | This macro simple define the end of an C++ namespace scope. More...
|
| |
| #define | START_VCL_NS namespace LazVCL { |
| | This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazVCL)
It is developer desire beatifuier. More...
|
| |
| #define | END_VCL_NS } |
| | This macro simple define the end of an C++ namespace scope. More...
|
| |
|
| typedef void | void |
| | simple place holder for "none" More...
|
| |
| typedef uint8_t | BYTE |
| | This macro define the data type BYTE. More...
|
| |
| typedef char | CHAR |
| | This typedef represents the FPC data type CHAR. More...
|
| |
| typedef uint16_t | WORD |
| | This typedef represents the data type WORD. More...
|
| |
| typedef uint32_t | DWORD |
| | This typedef represents the data type DWORD. More...
|
| |
| typedef uint64_t | QWORD |
| | This typedef represents the data type QWORD. More...
|
| |
| typedef CHAR * | STRING |
| | This macro represents the FPC data type STRING. More...
|
| |
some macros, and typedef's for better source maintain / readable.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition in file TTypes.h.
◆ END_CRT_NS
This macro simple define the end of an C++ namespace scope.
It is developer desire beatifuier. Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 102 of file TTypes.h.
◆ END_MANGLE
This macro simple define the end of an C++ de-mangle scope It is developer desire beatifuier.
Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 81 of file TTypes.h.
◆ END_RTL_NS
This macro simple define the end of an C++ namespace scope.
It is developer desire beatifuier. Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 123 of file TTypes.h.
◆ END_VCL_NS
This macro simple define the end of an C++ namespace scope.
It is developer desire beatifuier. Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 144 of file TTypes.h.
◆ FPC_BEGIN
This macro simple define the begin of an C scope.
It is developer desire beatifier the code. Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 51 of file TTypes.h.
◆ FPC_DLLFUNC
| #define FPC_DLLFUNC |
( |
|
x, |
|
|
|
y |
|
) |
| _$dll$laz_ ## y ## $ ## x |
FPC produce prefix code for each DLL class export; This macro hold proper code for maintain / readable.
It combine the compiler prefix with the class object name.
- Parameters
-
| x | - function name |
| y | = library name |
Possible values for y can be:
- crt
- rtl
- vcl, and many more
Example:
#define FPC_DLLFUNC(x, y)
FPC produce prefix code for each DLL class export; This macro hold proper code for maintain / readabl...
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 41 of file TTypes.h.
◆ FPC_END
This macro simple define the end of an C scope.
It is developer desire beatifier the code. Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 61 of file TTypes.h.
◆ START_CRT_NS
| #define START_CRT_NS namespace LazCRT { |
This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazCRT)
It is developer desire beatifuier.
Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 92 of file TTypes.h.
◆ START_MANGLE
| #define START_MANGLE extern "C" { |
This macro simple define the begin of an C++ de-mangle scope It is developer desire beatifuier.
Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 71 of file TTypes.h.
◆ START_RTL_NS
| #define START_RTL_NS namespace LazVCL { |
This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazRTL)
It is developer desire beatifuier.
Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 113 of file TTypes.h.
◆ START_VCL_NS
| #define START_VCL_NS namespace LazVCL { |
This macro helps, to indicate the different namespace used for C++ mangled scope,
and the differnt packages (here the LazVCL)
It is developer desire beatifuier.
Nothing else.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 134 of file TTypes.h.
◆ BYTE
This macro define the data type BYTE.
One Byte are 8-Bit - the smallest character that can be display.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 160 of file TTypes.h.
◆ CHAR
This typedef represents the FPC data type CHAR.
CHAR is limited to be one character. Please don't confuse with BYTE.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 168 of file TTypes.h.
◆ DWORD
This typedef represents the data type DWORD.
DWORD (double word) is a 32-bit data type.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 184 of file TTypes.h.
◆ QWORD
This typedef represents the data type QWORD.
QWORD (quad word) is a 64-bit data type.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 192 of file TTypes.h.
◆ STRING
This macro represents the FPC data type STRING.
STRING has limited length of 255 Bytes. Internal, it is declared in structure TD_SHORTSTRING.
Internal handled as char pointer type: char*.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 202 of file TTypes.h.
◆ void
simple place holder for "none"
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 152 of file TTypes.h.
◆ WORD
This typedef represents the data type WORD.
WORD is a 16-bit data type.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0
Definition at line 176 of file TTypes.h.
◆ SHORTSTRING()
Wrapper function for the FPC data type ShortSTRING.
STRING has limited length of 255 Bytes. Internal, it is declared as char*
The structure of this data type is defined in the struct in data fields section.
- Parameters
-
- Returns
- STRING : the string s as C char* type.
- Author
- paule32
- Date
- 2021-02-25
- Version
- 1.0


And the killer had then taken “trophy photographs” because of a “morbid interest in a dead woman’s genitalia.”
Prosecutor Brian Dickey made his closing speech at Auckland High Court saying there was a “compelling case of murder” against the 27-year-old defendant, who claims Grace died after consenting to being choked during sex.

“At some point of which she lost consciousness and would have become limp and lifeless and he had to carry on.
“And if that’s not reckless murder someone will have to explain to me what is.”
Mr Dickey said evidence by expert pathology witnesses was clear that it would take between five and ten minutes of sustained pressure before Grace, a university graduate from Essex, would have died.
And he said the Crown did not have to prove the man, whose identity is protected, had meant to kill her, only that he was reckless about what he was doing.
“If you kill someone by conscious risk taking that is murder,” he said.
“If you are satisfied he knew that he was doing something that was causing some level of harm.”
Mr Dickey dismissed the man’s version of events in a second police interview, where he claimed he had fallen asleep in the shower of his apartment and found Grace dead on the floor hours later, as a “labyrinth of storytelling.”
He had lied about trying to take an overdose of pills after she died because “he’s trying to make out he’s a decent human being.”
In fact, said Mr Dickey, the man had been searching for a place and a way of disposing of Grace’s body and then taken seven intimate photographs of her before watching hardcore porn.
These were all facts he had avoided telling police when he admitted Grace had died in his room after a Tinder date last December.
“There’s really no way out of the photographs for the defendant,” said Mr Dickey.
If they were taken while she was alive, he said, it was proof he was already planning her death and disposal.
If she was dead, he said, it proved the man had “eroticised her death.”
“You mustn’t forget she is just a living, breathing, happy young woman,” he told the jury of seven women and five men.
“She had a nice evening out. She had met someone she was interested in. She was walking around town, had some kissing
“We are not talking about a body we are talking about a real person.”
Mr Dickey said the man’s claim to police that he was distressed by what had happened to “a person he had a real connection with”, could be dismissed by the way he treated her with “a complete and utter absence of dignity.”
Rather than calling emergency services he had bought cleaning supplies and arranged another Tinder date for that afternoon.
And he said the man had still never admitted to causing her death, only “a little touchy touchy on the throat.”
The defence, said Mr Dickey, are not admitting murder or manslaughter, but instead: “Saying no foul, accident, he should walk free. It’s a terrible business but he didn’t do anything wrong.”
And, he said, the defence claimed what the accused did after Grace’s death was down to panic and did not help the jury decide how she died.
In fact, said Mr Dickey, the defendant had been “nonchalant” as he went to buy a second suitcase to replace the one in which he buried Grace’s body in the woods.
“He as cool as a cucumber, able to say to Detective Settle, ‘Don’t worry about that, that’s still in my room, go and have a look. I haven’t bought a suitcase to dispose of a body.
“Thats the level of planning, almost as if he is playing a game with the police, that tells you something about his mindset.
“He’s pretty good at this.”
Mr Dickey said Grace’s sexual history, during which she practiced consensual choking with a former partner, was irrelevant.

He added: “It can’t be consent because of what was happening.
Defence counsel Ian Brookie will address the jury this afternoon.


Look for famous and less famous manifestos. Create a personal manifesto. Write a set of statements, rules or a more essay-like piece about your opinion on the worlds's big theme's: economics, politics, culture, society, esthetics etc. Try to formulate them very specifically. Design the manifesto in a way that suits it's content.
To create a personal manifesto, I first needed to know which values and themes should be included in it. From the critical problems I can and will make values that are important to me after which I will find a suitable form for it to be personal to me.
I created
a list of values
to be included inside of the personal manifesto. Through brainstorming with
Mike Hendriks, I settled down for a form of the manifesto. It would become a
manifest.json
file in which I put my values inside of. The
end result
is great and very personal to me. It took some time to build the manifest
itself, but it payed of in the end I think. The feedback received from the
class was very positive and had no points of improvement.
I found this assignment to be eye opening of some sorts. I never thought about actual values that I adhere to. So this is confronting at a level which I reflect on how I interact with the world.
To create a meaningful creation, we first must think of what is meaningful for us, to make such a creation. To do so, this assignment was given to showcase values and other things you personally find meaningful.
I created the personal manifesto myself. Thanks
Mike Hendriks
for the cool manifest.json
idea!


(Check to make sure that links contain employee number)
HideButton2 extends HideButton (above) and changes the template (but keeps the onclick handler).
thinger blah stuff ${foo}
baz thud