Progressive Rock Top Albums / all subgenres - all record types - 2013 - all countries
Based on members ratings & PA algorithm
Here is some details about how we calculate the average rating of an album and the rank of an album.
-
Average rating: The classic calculation of the average but more weight is affected to the rating of progarchives.com collaborators and to rating with reviews.
- Rating only: Weight = 1
- Review by members : Weight = 10
- Review by PA Collaborators : Weight = 20
- Rank of an album: We use a calculation that compare an album average rating and number of ratings over all others albums in the query using this theory (http://en.wikipedia.org/wiki/Weighted_average) to create a variable every query "QWR" (AKA: Query Weighted Rating) use for ordering.
- By default, only albums with the average ratings above the average ratings of the requested query are displayed in theses lists, you can control this value in the parameters
| Rank | Cover | Ratings | Title Artist |
Genre (Record Type) |
BUY |
| 1 |
4.31 | 1650 ratings
QWR = 4.2956
|
The Raven That Refused To Sing (And Other Stories) Steven Wilson |
Crossover Prog Studio, 2013 |
Shop | |
| 2 |
4.21 | 455 ratings
QWR = 4.1772
|
The Snow Goose (Re-recording) Camel |
Symphonic Prog Studio, 2013 |
Shop | |
| 3 |
4.20 | 293 ratings
QWR = 4.1538
|
Multipurpose Trap Birds And Buildings |
Eclectic Prog Studio, 2013 |
Shop | |
| 4 |
4.16 | 921 ratings
QWR = 4.1447
|
The Mountain Haken |
Heavy Prog Studio, 2013 |
Shop | |
| 5 |
4.18 | 302 ratings
QWR = 4.1347
|
La Crudeltà Di Aprile Unreal City |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 6 |
4.13 | 686 ratings
QWR = 4.1107
|
English Electric (Part Two) Big Big Train |
Crossover Prog Studio, 2013 |
Shop | |
| 7 |
4.13 | 332 ratings
QWR = 4.0982
|
Ritual Nemrud |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 8 |
4.22 | 69 ratings
QWR = 4.0685
|
Evidence Taylor's Universe |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 9 |
4.18 | 87 ratings
QWR = 4.0622
|
Armenia Life Line Project |
Symphonic Prog Studio, 2013 |
Shop | |
| 10 |
4.28 | 48 ratings
QWR = 4.0590
|
Bilo 3.0 David Maxim Micic |
Progressive Metal Studio, 2013 |
Shop | |
| 11 |
4.07 | 880 ratings
QWR = 4.0579
|
Shrine Of New Generation Slaves Riverside |
Progressive Metal Studio, 2013 |
Shop | |
| 12 |
4.19 | 78 ratings
QWR = 4.0570
|
Of Things That Never Were The Worm Ouroboros |
Eclectic Prog Studio, 2013 |
Shop | |
| 13 |
4.15 | 99 ratings
QWR = 4.0506
|
Colored Sands Gorguts |
Tech/Extreme Prog Metal Studio, 2013 |
Shop | |
| 14 |
4.19 | 66 ratings
QWR = 4.0405
|
Snack(s) miRthkon |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 15 |
4.06 | 519 ratings
QWR = 4.0390
|
The Theory Of Everything Ayreon |
Progressive Metal Studio, 2013 |
Shop | |
| 16 |
4.30 | 35 ratings
QWR = 4.0292
|
Human (The Facts) Fughu |
Progressive Metal Studio, 2013 |
Shop | |
| 17 |
4.05 | 441 ratings
QWR = 4.0290
|
Fanfare & Fantasy Comedy Of Errors |
Neo-Prog Studio, 2013 |
Shop | |
| 18 |
4.10 | 131 ratings
QWR = 4.0253
|
Jeremias - Foreshadow of Forgotten Realms Circle of Illusion |
Progressive Metal Studio, 2013 |
Shop | |
| 19 |
4.09 | 147 ratings
QWR = 4.0252
|
Harvest Moon Votum |
Progressive Metal Studio, 2013 |
Shop | |
| 20 |
4.06 | 226 ratings
QWR = 4.0156
|
In Extremis Days Between Stations |
Eclectic Prog Studio, 2013 |
Shop | |
| 21 |
4.05 | 265 ratings
QWR = 4.0145
|
Le Porte Del Domani La Maschera Di Cera |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 22 |
4.05 | 241 ratings
QWR = 4.0126
|
The Tale Of The Golden King The Psychedelic Ensemble |
Neo-Prog Studio, 2013 |
Shop | |
| 23 |
4.02 | 580 ratings
QWR = 4.0086
|
Brief Nocturnes and Dreamless Sleep Spock's Beard |
Symphonic Prog Studio, 2013 |
Shop | |
| 24 |
4.05 | 179 ratings
QWR = 4.0041
|
Not A Good Sign Not A Good Sign |
Eclectic Prog Studio, 2013 |
Shop | |
| 25 |
4.03 | 314 ratings
QWR = 4.0020
|
Coal Leprous |
Tech/Extreme Prog Metal Studio, 2013 |
Shop | |
| 26 |
4.08 | 110 ratings
QWR = 3.9996
|
Ulver with Tromsø Chamber Orchestra: Messe I.X - VI.X Ulver |
Post Rock/Math rock Studio, 2013 |
Shop | |
| 27 |
4.07 | 106 ratings
QWR = 3.9940
|
Sodom & Gomorrah From.uz |
Eclectic Prog Studio, 2013 |
Shop | |
| 28 |
4.04 | 191 ratings
QWR = 3.9933
|
In Hoc Signo Ingranaggi della Valle |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 29 |
4.01 | 483 ratings
QWR = 3.9890
|
Desolation Rose The Flower Kings |
Symphonic Prog Studio, 2013 |
Shop | |
| 30 |
4.05 | 125 ratings
QWR = 3.9886
|
Lost in Time Flamborough Head |
Neo-Prog Studio, 2013 |
Shop | |
| 31 |
4.13 | 58 ratings
QWR = 3.9872
|
The Path of Least Existence Jet Black Sea |
Crossover Prog Studio, 2013 |
Shop | |
| 32 |
4.11 | 65 ratings
QWR = 3.9864
|
Guérison Setna |
Zeuhl Studio, 2013 |
Shop | |
| 33 |
4.09 | 78 ratings
QWR = 3.9838
|
After The Exhibition The Wrong Object |
Jazz Rock/Fusion Studio, 2013 |
Shop | |
| 34 |
4.07 | 80 ratings
QWR = 3.9723
|
Strigma Taproban |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 35 |
4.00 | 265 ratings
QWR = 3.9665
|
Le ver dans le fruit Nemo |
Eclectic Prog Studio, 2013 |
Shop | |
| 36 |
4.01 | 161 ratings
QWR = 3.9637
|
alieNatura Il Tempio delle Clessidre |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 37 |
4.01 | 160 ratings
QWR = 3.9613
|
The Tide, the Thief & River's End Caligula's Horse |
Progressive Metal Studio, 2013 |
Shop | |
| 38 |
4.03 | 101 ratings
QWR = 3.9597
|
Spirit Legend |
Neo-Prog Studio, 2013 |
Shop | |
| 39 |
4.06 | 70 ratings
QWR = 3.9583
|
All my Friends Jack O' The Clock |
Prog Folk Studio, 2013 |
Shop | |
| 40 |
3.99 | 230 ratings
QWR = 3.9556
|
Out of the Barnyard Fright Pig |
Symphonic Prog Studio, 2013 |
Shop | |
| 41 |
4.16 | 36 ratings
QWR = 3.9549
|
A Space Odyssey Part I Monolith RanestRane |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 42 |
3.97 | 363 ratings
QWR = 3.9546
|
A Feast Of Consequences Fish |
Neo-Prog Studio, 2013 |
Shop | |
| 43 |
4.09 | 51 ratings
QWR = 3.9520
|
The Eldritch Dark Blood Ceremony |
Heavy Prog Studio, 2013 |
Shop | |
| 44 |
4.08 | 53 ratings
QWR = 3.9500
|
Memoires Du Temps Orion |
Symphonic Prog Studio, 2013 |
Shop | |
| 45 |
4.03 | 87 ratings
QWR = 3.9474
|
Master & M Lizard |
Eclectic Prog Studio, 2013 |
Shop | |
| 46 |
3.98 | 201 ratings
QWR = 3.9472
|
The Final Breath Before November Edison's Children |
Neo-Prog Studio, 2013 |
Shop | |
| 47 |
4.03 | 82 ratings
QWR = 3.9467
|
White Rock Experience State Urge |
Crossover Prog Studio, 2013 |
Shop | |
| 48 |
3.97 | 297 ratings
QWR = 3.9462
|
Le Sacre Du Travail The Tangent |
Eclectic Prog Studio, 2013 |
Shop | |
| 49 |
4.01 | 95 ratings
QWR = 3.9422
|
Days Of Summer Gone Chris |
Neo-Prog Studio, 2013 |
Shop | |
| 50 |
3.99 | 121 ratings
QWR = 3.9388
|
The Ancient Tale Fatal Fusion |
Crossover Prog Studio, 2013 |
Shop | |
| 51 |
4.07 | 49 ratings
QWR = 3.9372
|
The Legend Of The Holy Circle Three Monks |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 52 |
4.10 | 40 ratings
QWR = 3.9369
|
Master Teeth Of The Sea |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 53 |
3.99 | 130 ratings
QWR = 3.9365
|
Alchemy Clive Nolan |
Neo-Prog Studio, 2013 |
Shop | |
| 54 |
3.98 | 126 ratings
QWR = 3.9287
|
Return to Mingulay Oceans 5 |
Crossover Prog Studio, 2013 |
Shop | |
| 55 |
4.04 | 56 ratings
QWR = 3.9283
|
Teethed Glory and Injury Altar of Plagues |
Experimental/Post Metal Studio, 2013 |
Shop | |
| 56 |
4.00 | 89 ratings
QWR = 3.9282
|
LMR Levin Minnemann Rudess |
Heavy Prog Studio, 2013 |
Shop | |
| 57 |
4.00 | 83 ratings
QWR = 3.9279
|
Ulisse: L'Alfiere Nero Progenesi |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 58 |
3.98 | 120 ratings
QWR = 3.9278
|
Ego Millenium |
Neo-Prog Studio, 2013 |
Shop | |
| 59 |
4.01 | 78 ratings
QWR = 3.9259
|
History Of The Visitation Guapo |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 60 |
3.97 | 145 ratings
QWR = 3.9245
|
Silhouette Moon Vienna Circle |
Neo-Prog Studio, 2013 |
Shop | |
| 61 |
4.00 | 83 ratings
QWR = 3.9244
|
Dedalo E Icaro Il Cerchio d'Oro |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 62 |
3.96 | 182 ratings
QWR = 3.9217
|
The Continuation The Windmill |
Heavy Prog Studio, 2013 |
Shop | |
| 63 |
3.99 | 84 ratings
QWR = 3.9201
|
[REDACTED] Also Eden |
Neo-Prog Studio, 2013 |
Shop | |
| 64 |
3.96 | 152 ratings
QWR = 3.9183
|
A Billion Years of Solitude Sky Architect |
Heavy Prog Studio, 2013 |
Shop | |
| 65 |
4.00 | 72 ratings
QWR = 3.9163
|
Gone Through Years Cyril |
Crossover Prog Studio, 2013 |
Shop | |
| 66 |
3.95 | 146 ratings
QWR = 3.9135
|
Still Life With Eggplant Motorpsycho |
Eclectic Prog Studio, 2013 |
Shop | |
| 67 |
3.98 | 84 ratings
QWR = 3.9121
|
Pictures In A Dream Arabs in Aspic |
Heavy Prog Studio, 2013 |
Shop | |
| 68 |
3.97 | 95 ratings
QWR = 3.9104
|
Secrets of Disguise The Samurai of Prog |
Crossover Prog Studio, 2013 |
Shop | |
| 69 |
3.97 | 101 ratings
QWR = 3.9103
|
Vertikal Cult of Luna |
Experimental/Post Metal Studio, 2013 |
Shop | |
| 70 |
4.04 | 44 ratings
QWR = 3.9064
|
Anthem to creation Until Rain |
Progressive Metal Studio, 2013 |
Shop | |
| 71 |
4.04 | 41 ratings
QWR = 3.9056
|
Use And Ornament Regal Worm |
Crossover Prog Studio, 2013 |
Shop | |
| 72 |
3.93 | 209 ratings
QWR = 3.9055
|
The Man Left In Space Cosmograf |
Neo-Prog Studio, 2013 |
Shop | |
| 73 |
3.94 | 181 ratings
QWR = 3.9050
|
Turn Off Shamall |
Neo-Prog Studio, 2013 |
Shop | |
| 74 |
4.03 | 45 ratings
QWR = 3.9042
|
Fanfare Du Chaos Rhùn |
Zeuhl Studio, 2013 |
Shop | |
| 75 |
3.96 | 96 ratings
QWR = 3.9015
|
Psykerion Thought Chamber |
Progressive Metal Studio, 2013 |
Shop | |
| 76 |
3.96 | 94 ratings
QWR = 3.9010
|
Das Geheimnis Traumhaus |
Symphonic Prog Studio, 2013 |
Shop | |
| 77 |
4.07 | 32 ratings
QWR = 3.8995
|
ReEvolution Cynthesis |
Progressive Metal Studio, 2013 |
Shop | |
| 78 |
4.02 | 44 ratings
QWR = 3.8968
|
Worn Out Taylor's Universe |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 79 |
3.99 | 58 ratings
QWR = 3.8964
|
Everything is Connected Dead Heroes Club |
Neo-Prog Studio, 2013 |
Shop | |
| 80 |
3.99 | 59 ratings
QWR = 3.8958
|
Droga Vespero |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 81 |
3.95 | 102 ratings
QWR = 3.8954
|
A Day In The Life Of A Universal Wanderer Gandalf's Fist |
Neo-Prog Studio, 2013 |
Shop | |
| 82 |
3.91 | 261 ratings
QWR = 3.8907
|
Darkness In A Different Light Fates Warning |
Progressive Metal Studio, 2013 |
Shop | |
| 83 |
3.93 | 120 ratings
QWR = 3.8903
|
PFM In Classic - Da Mozart A Celebration Premiata Forneria Marconi (PFM) |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 84 |
3.90 | 339 ratings
QWR = 3.8894
|
The Greatest Show on Earth Airbag |
Neo-Prog Studio, 2013 |
Shop | |
| 85 |
4.03 | 36 ratings
QWR = 3.8881
|
One Of Us Is The Killer The Dillinger Escape Plan |
Tech/Extreme Prog Metal Studio, 2013 |
Shop | |
| 86 |
4.01 | 43 ratings
QWR = 3.8878
|
Láquesis Láquesis |
Symphonic Prog Studio, 2013 |
Shop | |
| 87 |
3.91 | 249 ratings
QWR = 3.8869
|
psychoanorexia T |
Neo-Prog Studio, 2013 |
Shop | |
| 88 |
3.97 | 60 ratings
QWR = 3.8857
|
Liminal Exivious |
Tech/Extreme Prog Metal Studio, 2013 |
Shop | |
| 89 |
3.96 | 66 ratings
QWR = 3.8847
|
Winter Soulstice Sonus Umbra |
Crossover Prog Studio, 2013 |
Shop | |
| 90 |
4.00 | 43 ratings
QWR = 3.8835
|
Euporie Tide Causa Sui |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 91 |
3.93 | 106 ratings
QWR = 3.8833
|
Pelagial The Ocean |
Experimental/Post Metal Studio, 2013 |
Shop | |
| 92 |
3.91 | 156 ratings
QWR = 3.8815
|
Sensitività La Coscienza di Zeno |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 93 |
3.94 | 78 ratings
QWR = 3.8782
|
Automatic Day Little Atlas |
Neo-Prog Studio, 2013 |
Shop | |
| 94 |
3.98 | 48 ratings
QWR = 3.8781
|
7 Toxic Smile |
Progressive Metal Studio, 2013 |
Shop | |
| 95 |
3.97 | 49 ratings
QWR = 3.8729
|
The Circle & the Blue Door Purson |
Crossover Prog Studio, 2013 |
Shop | |
| 96 |
3.93 | 79 ratings
QWR = 3.8727
|
The Gates Of Tomorrow La Maschera Di Cera |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 97 |
3.95 | 62 ratings
QWR = 3.8726
|
The Machine Hibernal |
Post Rock/Math rock Studio, 2013 |
Shop | |
| 98 |
3.94 | 67 ratings
QWR = 3.8697
|
Under The Shadow Of The Moon Janus |
Crossover Prog Studio, 2013 |
Shop | |
| 99 |
4.00 | 35 ratings
QWR = 3.8694
|
Overcoming The Monster KingBathmat |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 100 |
3.97 | 45 ratings
QWR = 3.8670
|
Between The Madness Vangough |
Progressive Metal Studio, 2013 |
Shop | |
| 101 |
3.91 | 98 ratings
QWR = 3.8636
|
Hubardo Kayo Dot |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 102 |
3.88 | 267 ratings
QWR = 3.8614
|
Himlabacken Vol.1 Moon Safari |
Symphonic Prog Studio, 2013 |
Shop | |
| 103 |
3.91 | 79 ratings
QWR = 3.8594
|
From The Small Hours Of Weakness Verbal Delirium |
Crossover Prog Studio, 2013 |
Shop | |
| 104 |
3.97 | 37 ratings
QWR = 3.8585
|
Das Reboot Zip Tang |
Eclectic Prog Studio, 2013 |
Shop | |
| 105 |
3.88 | 167 ratings
QWR = 3.8577
|
Altered State TesseracT |
Progressive Metal Studio, 2013 |
Shop | |
| 106 |
3.95 | 46 ratings
QWR = 3.8559
|
Cobra Fakir Miriodor |
RIO/Avant-Prog Studio, 2013 |
Shop | |
| 107 |
3.90 | 99 ratings
QWR = 3.8557
|
Tawa Sarira Jinetes Negros |
Progressive Metal Studio, 2013 |
Shop | |
| 108 |
3.91 | 69 ratings
QWR = 3.8536
|
The System of Events Crystal Palace |
Neo-Prog Studio, 2013 |
Shop | |
| 109 |
3.91 | 62 ratings
QWR = 3.8496
|
At The End Of Myself Echoes Of Giants |
Crossover Prog Studio, 2013 |
Shop | |
| 110 |
3.92 | 54 ratings
QWR = 3.8480
|
Solar Power Lost World |
Crossover Prog Studio, 2013 |
Shop | |
| 111 |
3.92 | 51 ratings
QWR = 3.8470
|
Mystic Spirit Kerrs Pink |
Prog Folk Studio, 2013 |
Shop | |
| 112 |
3.93 | 45 ratings
QWR = 3.8425
|
Good Things Half Past Four |
Eclectic Prog Studio, 2013 |
Shop | |
| 113 |
3.88 | 90 ratings
QWR = 3.8422
|
The Trip Djam Karet |
Eclectic Prog Studio, 2013 |
Shop | |
| 114 |
3.90 | 69 ratings
QWR = 3.8418
|
Tales From Sheepfather's Grove Johannes Luley |
Crossover Prog Studio, 2013 |
Shop | |
| 115 |
3.91 | 51 ratings
QWR = 3.8410
|
On The Edge Arlon |
Neo-Prog Studio, 2013 |
Shop | |
| 116 |
3.88 | 99 ratings
QWR = 3.8398
|
The Audio Guide To Happiness Part 2 Jolly |
Neo-Prog Studio, 2013 |
Shop | |
| 117 |
3.91 | 54 ratings
QWR = 3.8392
|
Ghosts & Memories The Black Noodle Project |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 118 |
3.91 | 46 ratings
QWR = 3.8367
|
How Much Are You Willing To Forget? Flicker |
Crossover Prog Studio, 2013 |
Shop | |
| 119 |
3.88 | 77 ratings
QWR = 3.8366
|
Target Earth Voivod |
Tech/Extreme Prog Metal Studio, 2013 |
Shop | |
| 120 |
3.87 | 99 ratings
QWR = 3.8361
|
Aleatorica Karfagen |
Symphonic Prog Studio, 2013 |
Shop | |
| 121 |
3.87 | 98 ratings
QWR = 3.8339
|
Nine Lives Von Hertzen Brothers |
Crossover Prog Studio, 2013 |
Shop | |
| 122 |
3.93 | 35 ratings
QWR = 3.8331
|
Immortal Remains Rick Miller |
Crossover Prog Studio, 2013 |
Shop | |
| 123 |
3.85 | 191 ratings
QWR = 3.8325
|
The Twenty Seven Club Magenta |
Neo-Prog Studio, 2013 |
Shop | |
| 124 |
3.86 | 102 ratings
QWR = 3.8256
|
Conjure Herd Of Instinct |
Eclectic Prog Studio, 2013 |
Shop | |
| 125 |
3.91 | 40 ratings
QWR = 3.8255
|
Dino Rocket Oxygen Yuka & Chronoship |
Neo-Prog Studio, 2013 |
Shop | |
| 126 |
3.90 | 42 ratings
QWR = 3.8238
|
Funfair Fantasy Trion |
Symphonic Prog Studio, 2013 |
Shop | |
| 127 |
3.85 | 127 ratings
QWR = 3.8231
|
The Lamplighter Anima Mundi |
Symphonic Prog Studio, 2013 |
Shop | |
| 128 |
3.86 | 82 ratings
QWR = 3.8223
|
Particles Osada Vida |
Heavy Prog Studio, 2013 |
Shop | |
| 129 |
3.85 | 111 ratings
QWR = 3.8212
|
Paraíso Subsignal |
Neo-Prog Studio, 2013 |
Shop | |
| 130 |
3.88 | 51 ratings
QWR = 3.8205
|
The Last Tribe Dialeto |
Heavy Prog Studio, 2013 |
Shop | |
| 131 |
3.89 | 36 ratings
QWR = 3.8131
|
Prophecy Solstice |
Neo-Prog Studio, 2013 |
Shop | |
| 132 |
3.83 | 188 ratings
QWR = 3.8129
|
Lifesigns Lifesigns |
Neo-Prog Studio, 2013 |
Shop | |
| 133 |
3.83 | 170 ratings
QWR = 3.8099
|
All Is One Orphaned Land |
Experimental/Post Metal Studio, 2013 |
Shop | |
| 134 |
3.89 | 34 ratings
QWR = 3.8082
|
Habitual Levitations (Instilling Words With Tones) Intronaut |
Experimental/Post Metal Studio, 2013 |
Shop | |
| 135 |
3.89 | 33 ratings
QWR = 3.8073
|
Truths, Lies & Half Lies Mr. So & So |
Neo-Prog Studio, 2013 |
Shop | |
| 136 |
3.82 | 109 ratings
QWR = 3.8010
|
One For Sorrow, Two For Joy Thieves' Kitchen |
Eclectic Prog Studio, 2013 |
Shop | |
| 137 |
3.82 | 96 ratings
QWR = 3.7983
|
Ascension The Inner Road |
Symphonic Prog Studio, 2013 |
Shop | |
| 138 |
3.85 | 48 ratings
QWR = 3.7970
|
From The Days Of Deucalion, Chapter 1 Leap Day |
Neo-Prog Studio, 2013 |
Shop | |
| 139 |
3.84 | 57 ratings
QWR = 3.7954
|
The Chandrasekhar Limit Zenit |
Neo-Prog Studio, 2013 |
Shop | |
| 140 |
3.81 | 102 ratings
QWR = 3.7901
|
Culture Clash The Aristocrats |
Heavy Prog Studio, 2013 |
Shop | |
| 141 |
3.84 | 39 ratings
QWR = 3.7889
|
Day And Night Dynamo Bliss |
Crossover Prog Studio, 2013 |
Shop | |
| 142 |
3.83 | 52 ratings
QWR = 3.7865
|
The Migration Scale The Summit |
Progressive Metal Studio, 2013 |
Shop | |
| 143 |
3.83 | 41 ratings
QWR = 3.7854
|
D'AccorD III D'AccorD |
Heavy Prog Studio, 2013 |
Shop | |
| 144 |
3.83 | 42 ratings
QWR = 3.7851
|
Matricide La Tulipe Noire |
Neo-Prog Studio, 2013 |
Shop | |
| 145 |
3.82 | 50 ratings
QWR = 3.7837
|
A Lifeblood Psalm The Twenty Committee |
Crossover Prog Studio, 2013 |
Shop | |
| 146 |
3.82 | 49 ratings
QWR = 3.7796
|
Enigma Aeon Zen |
Progressive Metal Studio, 2013 |
Shop | |
| 147 |
3.81 | 54 ratings
QWR = 3.7764
|
You Have a Chance Camelias Garden |
Prog Folk Studio, 2013 |
Shop | |
| 148 |
3.79 | 115 ratings
QWR = 3.7722
|
The Dream Harbour Willowglass |
Symphonic Prog Studio, 2013 |
Shop | |
| 149 |
3.78 | 193 ratings
QWR = 3.7715
|
Dimensionaut Sound Of Contact |
Crossover Prog Studio, 2013 |
Shop | |
| 150 |
3.78 | 188 ratings
QWR = 3.7699
|
Echo Street Amplifier |
Psychedelic/Space Rock Studio, 2013 |
Shop | |
| 151 |
3.81 | 31 ratings
QWR = 3.7642
|
Selling The Aggression The Aurora Project |
Progressive Metal Studio, 2013 |
Shop | |
| 152 |
3.78 | 55 ratings
QWR = 3.7615
|
The Root, the Leaf & the Bone Manning |
Eclectic Prog Studio, 2013 |
Shop | |
| 153 |
3.80 | 33 ratings
QWR = 3.7605
|
Europa Minor Tugs |
Rock Progressivo Italiano Studio, 2013 |
Shop | |
| 154 |
3.77 | 79 ratings
QWR = 3.7588
|
The Afterman: Descension Coheed And Cambria |
Crossover Prog Studio, 2013 |
Shop | |
| 155 |
3.79 | 33 ratings
QWR = 3.7564
|
Mother Turtle Mother Turtle |
Heavy Prog Studio, 2013 |
Shop | |
| 156 |
3.77 | 40 ratings
QWR = 3.7495
|
Rubidium Maschine |
Progressive Metal Studio, 2013 |
Shop | |
| 157 |
3.76 | 38 ratings
QWR = 3.7446
|
A Life To Die For Royal Hunt |
Progressive Metal Studio, 2013 |
Shop | |
| 158 |
3.73 | 53 ratings
QWR = 3.7291
|
Cinéma du Vieux Cartier Red Sand |
Neo-Prog Studio, 2013 |
Shop | |
| 159 |
3.72 | 31 ratings
QWR = 3.7230
|
Triangulate Bolus |
Neo-Prog Studio, 2013 |
Shop | |
| 160 |
3.72 | 77 ratings
QWR = 3.7224
|
Home Away From Home Elephants Of Scotland |
Neo-Prog Studio, 2013 |
Shop |


Cache loading refers to the process whereby a cache transparently (lazy) load or generate values for requested key(s). This technique can often be more efficient then requiring a user to fill up the cache in advance. A cache loader might load data from an external site, a databases or just a plain text-based file. Data can also be generated on the fly, for example, as the result of a time consuming calculation. Finally, a cache loader can be used for prefetching, that is getting data into the cache well before it is needed. So data can be served immediatly when it is first requested, and thereby less latency for the users.
A cache loader implementation is specified by the user before a cache is initialized and is responsible for loading or creating the value for a specified key.
There are current two ways to create a CacheLoader: 1) Creating a simple function implementing the Op interface. 2) Annotate a public method with the CacheLoader annotation.
The Op interface is used a lot in Cake and instead of creating a new interface we will use it here as well. The interface takes a single argument which is the key that the user specifies when calling the get() method of a cache. The return value of the method must be the value for which the cache should associate the specified key with. For example, if we want to create a cache the caches the result of a calculation in order to avoid repeating the computations constantly we can define the following cache loader:
public class ComplexCalculation implements Op<Integer, Integer> { public Integer op(Integer i) { return i+i+i+i+i; //well maybe not that complex } }
We also need to tell the cache that it must use this loader, whenever no mapping exists for a key.
CacheConfiguration<Integer, Integer> conf = CacheConfiguration.newConfiguration(); conf.withLoading().setLoader(new ComplexCalculation()); Cache<String, String> cache = new SynchronizedCache(conf);
Now when cache.get(1) is called the first time, the cache will use the ComplexCalculation instance to calculate the value. But when cache.get(1) calling the second time, the cache will return the cached content instead of calculating the value again.
// 1. hit - Uses the cache loader System.out.println(cache.get(1)); // outputs 5 // 2. hit - Returns the cached version System.out.println(cache.get(1)); // outputs 5
Instead of implementing the Op interface you can also annotate a method with the CacheLoader annotation. Which allows for parsing additional parameters between the user, cache and cache loader.
The first parameter of the method annotated with the CacheLoader annotations must be the key for which the user is requesting a value. It can be any non-primitive type. The second parameter is optional and either be an AttributeMap or a MutableAttributeMap. If the second parameter is an AttributeMap the user and cache can provide additional arguments to the loader besides the actual key. If the second parameter is a MutableAttributeMap the cache loader can specify parameters back to the cache.
The specified key should contain enough information to allow the cache loader to retrieve the matching value. The MutableAttributeMap can be be used by the cache to specify additional properties that the cache loader can use. It it also used by the cache loader to transfer metadata about the loaded value back to the caller. For example, the size of the value or the cost of retrieving the value. Simple cache loader will most likely just ignore the specified attribute map. The following example shows a cache loader taking a String formatted as an url and retrieves the corresponding content as a String:import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.URL; import org.codehaus.cake.cache.service.loading.BlockingCacheLoader; import org.codehaus.cake.util.attribute.MutableAttributeMap; public class SimpleUrlLoader implements BlockingCacheLoader<String, String> { public String load(String key, MutableAttributeMap ignore) throws Exception { BufferedReader in = new BufferedReader(new InputStreamReader(new URL(key).openStream())); StringBuilder sb = new StringBuilder(); int str; while ((str = in.read()) != -1) { sb.append((char) str); } in.close(); return sb.toString(); } }
CacheConfiguration<String, String> conf = CacheConfiguration.newConfiguration(); conf.withLoading().setLoader(new SimpleUrlLoader()); Cache<String, String> cache = new SynchronizedCache(conf); System.out.println(cache.get("http://www.java.net")); // 1. hit - Uses the cache loader System.out.println(cache.get("http://www.java.net")); // 2. hit - Returns the cached version
cache.with().loading().load("http://www.wikipedia.org"); //will load the specified url only if it is not already present in the cache or if it needs refreshing cache.with().loading().loadAll(); // will reload all elements in the cache that is expired or needs refreshing
but you want it to be available until it has been refreshed. A number of methods starting with *load*, for example, load(K key), which will load the value if it is not already present in the cache or if it expired. The other group of methods starts with forceLoad* and will always load a new value even if valid one is already present in the cache. Unless otherwise specified the cache will load the values asynchronously. Ordinary loading Examples of various loading calls: Will load the front of page of java.net into the cache if it is not already present. Or if an entry already exist and a needs-reload-predicate has been configured and evaluates the existing to true.
cache.with().loading().load("http://www.java.net"); //will load the specified url even if it already present in the cache
cache.with().loading().loadAll();
cache.with().loading().load("http://www.wikipedia.org"); //will load the specified url only if it is not already present in the cache or if it is expired or needs refreshing cache.with().loading().loadAll(); // will reload all elements in the cache that is expired or needs refreshing
cache.with().loadingForced().load("http://www.java.net");
cache.with().loadingForced().loadAll();
cache.filter().onValue(new Predicate<String>() { public boolean op(String content) { return content.length() > 10 * 1024; } }).with().loadingForced().loadAll();
One way is to schedule full reloads of cache every xx minute/hour. The reload will be performed by a background thread and will not interfere with the response time of users requests, except for any generally load that the full load might put on the system. For example, this snippet will schedule a full reload of the cache every 15 minute.
If a full reload uses to many of your systems resources. You can instead schedule partial reloads. The idea being that instead of, for example, reloading all your data every 15 minute, you instead reload 1/15 of your data every minute. The effect is the same as full reload, but it is just better spread out over time. For example, this snippet will schedule a partial reload that makes sure every part of the cache is refreshed every hour.
Currently there is no direct support for expiration of elements. But depending on your needs you can most likely emulate it rather easily. If by e Not directly. But you can easily emulate. //Create Attribute and add it to cache //Setup scheduler cache.filter().on(ExpiresAt, LongPredicates.lessThen(System.currentMillies)).clear(); //insert entries, with expiration time.


Virginia Democrat accused of sex with teen secretary wins state Senate seat
by Louis CasianoA Virginia lawmaker once jailed for having sex with his underage secretary won election to the state Senate Tuesday.
Democrat Joe Morrissey easily defeated Independent Waylin Ross by winning more than 64 percent of the vote to represent the 16th Senate District, a seat long held by Democrats.
VIRGINIA DEMOCRAT WINS STATE HOUSE SEAT AFTER 2017 ELECTION LOSS IN RANDOM DRAWING
Morrissey, a former state legislator, spent six months in jail in 2015 after pleading guilty to misdemeanor delinquency of a minor after a sex scandal involving his then-17-year-old secretary, whom he later married.
The couple has three children, WJLA-TV reported.
CLICK HERE TO GET THE FOX NEWS APP
Morrissey continued serving in the state legislature while he was jailed. He made an unsuccessful bid for the mayoralty of Richmond in 2016 and had his law license revoked last year, according to the station.
Democrats picked up a net of two state Senate seats and a net of six seats in the House of Delegates Tuesday, taking control of both chambers of Virginia's legislature for the first time in more than two decades.


EQbeats.org I.E. the My Little Pony music API
Steps to planting a my little pony bomb (also how to make code confusing)
- Make the naming confusing and hard to read
- Put the functions all over (spaggetti code)
- Minify the code
- Add actions Asynchronously (see audio player)


Enter Your Work Experience Info.
You Must enter a valid Professional Name!
Professional Name
You Must enter a Professional Level!
Professional Level
You Must enter a valid Organization Name!
Organization Name
You Must enter a valid Duty you have!
Duty
You Must enter a valid Start Date!
Start Date
You Must enter a valid End Date!
End Date
Submit
Reset


barista.xml
The barista.xml is an XML files that used to record four main parts:
- < proteins > ... < /proteins >
- < subset_proteins > ... < /subset_proteins >
- < peptides > ... < /peptides >
- < psms > ... < /psms >
- Proteins:contains the ranked list of groups of indistinguishable target proteins. Each protein entry includes the following fields:
- protein group: a number that identifies a group.
- q-value: The minimal protein-level false discovery rate at which this protein is deemed significant. This q-value is computed based on the ranking of the proteins induced by the Barista score.
- score: The score assigned to the proteins by Barista. Higher values correspond to more confident identifications.
- protein_ids: proteins in the protein group.
- alternative_peptide_id: peptides are considered indistinguishable if they have identical amino acid sequences or they differ only by I/L or T/S in the same position in the peptide. If the peptides shared by the group are not identical, they are listed immediately after the proteins they belong to.
- peptide_ids: belong to each of the proteins in the group.
For example, suppose that
- protein_a has peptide KLEAEVEALKK       // 'L' in second position
- and peptide VLGAK
- protein_b has peptide KIEAEVEALKK       // 'I' in second position
- and peptide VLGAK
Then the xml entry could look like this
- < proteins >
- < q_value > 0 < /q_value >
- < score > 8.9 > < /score >
- < protein_group group_id="1" >
- < protein_ids >
- < protein_id > protein_a < /protein_id >
- < alternative_peptide_id > KLEAEVEALKK < /alternative_peptide_id >
- < protein_id > protein_b < /protein_id >
- < alternative_peptide_id > KIEAEVEALKK < /alternative_peptide_id >
- < /protein_ids >
- < peptide_ids >
- < peptide_id > VLGAK < /peptide_id >
- < /peptide_ids >
- < /protein_group >
- < /proteins >
Subset proteins contains groups of indistinguishable proteins, which constitute a subset of some group in the proteins section in terms of the peptides identified in these proteins. Each entry includes
- group id and parent group id: the identifier of the group and the identifier of the protein group which has the superset of the peptide set belonging the current group
- protein_ids : proteins that belong to the group
- peptide_ids: peptides that belong to the proteins in the group.
Peptides contains a ranked list of target peptides. Each peptide entry includes:
- peptide: Peptide amino acid sequence.
- q-value: The minimal peptide-level false discovery rate at which this peptide is deemed significant. This q-value is computed based on the ranking of the peptides induced by the Barista score.
- score: The score assigned to the peptide by Barista. Higher values correspond to more confident identifications.
- main_psm_id: The PSM identifier based on which the peptide received its score. A peptide score is the maximum over all the PSMs that contain this peptide.
- psm_ids: The identifiers of all the PMS that contain this peptide .
- protein_ids: All the proteins that contain this peptide and were infered based on some PSMs from the database search.
PSMs contains ranked list of target peptide-spectrum matches. The following columns are included:
- psm_id: PSM identifier.
- q-value: The minimal PSM-level false discovery rate at which this PSM is deemed significant. This q-value is computed based on the ranking of the PSMs induced by the Barista score.
- score: The score assigned to the PSM by Barista. Higher values correspond to more confident identifications.
- scan: the scan number
- charge: the inferred charge state
- precursor_mass: precrusor mass as recorded during the MS1 scan
- peptide: the peptide sequence
- filename: name of the file in which the PSM appears


[gecode-users] error in documentation for PC_INT_DOM
Christian Schulte
schulte at imit.kth.se
Mon May 15 15:57:46 CEST 2006
Martin, thanks. I just fixed it in the trunk.
Christian
--
Christian Schulte, http://www.imit.kth.se/~schulte/
-----Original Message-----
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Martin Mann
Sent: Monday, May 15, 2006 2:55 PM
To: gecode user list
Subject: [gecode-users] error in documentation for PC_INT_DOM
found an error in documentation
===========================================================
const PropCond Gecode::Int::PC_INT_DOM = PC_INT_BND + 1
Propagate when domain changes.
If a propagator p depends on a view x with propagation condition
PC_INT_VAL, then p is propagated when a domain update operation on x
returns the modification event ME_INT_VAL, ME_INT_BND, or ME_INT_DOM.
Definition at line 81 of file var.icc.
===========================================================
there should stand a PC_INT_DOM instead a PC_INT_VAL in the second
sentence..
;)
Martin
_______________________________________________
Gecode users mailing list
users at gecode.org https://www.gecode.org/mailman/listinfo/gecode-users
More information about the gecode-users
mailing list


Richard hails from Tulsa. He has earned degrees from the University of Oklahoma and Stanford. (Go Sooners and Cardinal!) Before starting Pied Piper, he worked for Hooli as a part time software developer. While his work focuses on applied information theory, mostly optimizing lossless compression schema of both the length-limited and adaptive variants, his non-work interests range widely, everything from quantum computing to chaos theory. He could tell you about it, but THAT would NOT be a “length-limited” conversation!
Pied Piper is a multi-platform technology based on a proprietary universal compression algorithm that has consistently fielded high Weisman Scores™ that are not merely competitive, but approach the theoretical limit of lossless compression.
Global movement of free coding clubs for young people.
There is no spoon.
Innovative middle-out compression algorithm that changes the way we store data.
It is my pleasure to recommend Richard, his performance working as a consultant for Main St. Company proved that he will be a valuable addition to any company.


BLOGS of Friends
The Life and Times and Amazing Adventures of DJ Bunny Ears
GOING SOFLO - the blog of a friend’s wife who I have never met, but I do like her writing…
When I need a good laugh:
Other stuff I like:
Awesome Image Blogging - FFFFOUND!
Collage Artist Blog - Notpaper
The Scale Of The Universe (like a modern Powers Of Ten)


I am experienced in leveraging agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy. Foster collaborative thinking to further the overall value proposition.
Managing front end, back end, databases, server. Taking client feedback and making changes accordingly
Percentage: 70.73
Percentage: 74.43
Percentage: 70.20
Percentage: 80.40
Apart from being a web developer, I enjoy most of my time being outdoors. Hanging out with friends and family. Playing cricket in local parks. Flying kites on terrace with kids.
When forced indoors, I follow a number of sci-fi and fantasy genre movies and television shows, I also like to play multiplayer games with friends, and I spend a large amount of my free time exploring the latest technolgy advancements in the front-end web development world.


Library: Strings
Does not inherit
|
getline() operator!=() operator>>() |
operator>() operator>=() operator<<() |
operator<() operator<=() operator+() |
operator==() swap() |
A templatized class for handling sequences of character-like entities. string and wstring are specialized variations of basic_string for chars and wchar_ts, respectively.typedef basic_string <char> string;typedef basic_string <wchar_t> wstring;
#include <string> namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_string; }
Class basic_string is a homogeneous collection of character-like entities that includes string functions such as compare(), append(), assign(), insert(), remove(), and replace(), along with various searches. The class also functions as an STL sequence container that provides random access iterators. This allows some of the generic algorithms to apply to strings.
Any underlying character-like type may be used as long as an appropriate char_traits class is included or the default traits class is applicable.
namespace std { template <class charT, class traits = char_traits<charT>, class Allocator = allocator<charT> > class basic_string { public: // Types typedef traits traits_type; typedef typename traits::char_type value_type; typedef Allocator allocator_type; typedef typename Allocator::size_type size_type; typedef typename Allocator::difference_type difference_type; typedef typename Allocator::reference reference; typedef typename Allocator::const_reference const_reference; typedef typename Allocator::pointer pointer; typedef typename Allocator::const_pointer const_pointer; typedef typename Allocator::pointer iterator; typedef typename Allocator::const_pointer const_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; typedef std::reverse_iterator<iterator> reverse_iterator; static const size_type npos = -1; // Constructors/Destructors explicit basic_string(const Allocator& = Allocator()); basic_string(const basic_string<charT, traits, Allocator>&); basic_string(const basic_string&, size_type, size_type = npos, const Allocator& a = Allocator()); basic_string(const charT*, size_type, const Allocator& = Allocator()); basic_string(const charT*, const Allocator& = Allocator()); basic_string(size_type, charT, const Allocator& = Allocator()); template <class InputIterator> basic_string(InputIterator, InputIterator, const Allocator& = Allocator()); ~basic_string(); // Assignment operators basic_string& operator=(const basic_string&); basic_string& operator=(const charT*); basic_string& operator=(charT); // Iterators iterator begin(); const_iterator begin() const; iterator end(); const_iterator end() const; reverse_iterator rbegin(); const_reverse_iterator rbegin() const; reverse_iterator rend(); const_reverse_iterator rend() const; // Capacity size_type size() const; size_type length() const; size_type max_size() const; void resize(size_type, charT); void resize(size_type); size_type capacity() const; void reserve(size_type = 0); void clear(); bool empty() const; // Element access const_reference operator[](size_type) const; reference operator[](size_type); const_reference at(size_type) const; reference at(size_type); // Modifiers basic_string& operator+=(const basic_string&); basic_string& operator+=(const charT*); basic_string& operator+=(charT); basic_string& append(const basic_string&); basic_string& append(const basic_string&, size_type, size_type); basic_string& append(const charT*, size_type); basic_string& append(const charT*); basic_string& append(size_type, charT); template<class InputIterator> basic_string& append(InputIterator, InputIterator); void push_back(charT); basic_string& assign(const basic_string&); basic_string& assign(const basic_string&, size_type, size_type); basic_string& assign(const charT*, size_type); basic_string& assign(const charT*); basic_string& assign(size_type, charT); template<class InputIterator> basic_string& assign(InputIterator, InputIterator); basic_string& insert(size_type, const basic_string&); basic_string& insert(size_type, const basic_string&, size_type, size_type); basic_string& insert(size_type, const charT*, size_type); basic_string& insert(size_type, const charT*); basic_string& insert(size_type, size_type, charT); iterator insert(iterator, charT = charT()); void insert(iterator, size_type, charT); template<class InputIterator> void insert(iterator, InputIterator, InputIterator); basic_string& erase(size_type = 0, size_type= npos); iterator erase(iterator); iterator erase(iterator, iterator); basic_string& replace(size_type, size_type, const basic_string&); basic_string& replace(size_type, size_type, const basic_string&, size_type, size_type); basic_string& replace(size_type, size_type, const charT*, size_type); basic_string& replace(size_type, size_type, const charT*); basic_string& replace(size_type, size_type, size_type, charT); basic_string& replace(iterator, iterator, const basic_string&); basic_string& replace(iterator, iterator, const charT*, size_type); basic_string& replace(iterator, iterator, const charT*); basic_string& replace(iterator, iterator, size_type, charT); template<class InputIterator> basic_string& replace(iterator, iterator, InputIterator, InputIterator); size_type copy(charT*, size_type, size_type = 0) const; void swap(basic_string<charT, traits, Allocator>&); // String operations const charT* c_str() const; const charT* data() const; allocator_type& get_allocator() const; size_type find(const basic_string&, size_type = 0) const; size_type find(const charT*, size_type, size_type) const; size_type find(const charT*, size_type = 0) const; size_type find(charT, size_type = 0) const; size_type rfind(const basic_string&, size_type = npos) const; size_type rfind(const charT*, size_type, size_type) const; size_type rfind(const charT*, size_type = npos) const; size_type rfind(charT, size_type = npos) const; size_type find_first_of(const basic_string&, size_type = 0) const; size_type find_first_of(const charT*, size_type, size_type) const; size_type find_first_of(const charT*, size_type = 0) const; size_type find_first_of(charT, size_type = 0) const; size_type find_last_of(const basic_string&, size_type = npos) const; size_type find_last_of(const charT*, size_type, size_type) const; size_type find_last_of(const charT*, size_type = npos) const; size_type find_last_of(charT, size_type = npos) const; size_type find_first_not_of(const basic_string&, size_type = 0) const; size_type find_first_not_of(const charT*, size_type, size_type) const; size_type find_first_not_of(const charT*, size_type = 0) const; size_type find_first_not_of(charT, size_type = 0) const; size_type find_last_not_of(const basic_string&, size_type = npos) const; size_type find_last_not_of(const charT*, size_type, size_type) const; size_type find_last_not_of(const charT*, size_type = npos) const; size_type find_last_not_of(charT, size_type = npos) const; basic_string substr(size_type = 0, size_type = npos) const; int compare(const basic_string&) const; int compare(size_type, size_type, const basic_string&) const; int compare(size_type, size_type, const basic_string&, size_type, size_type) const; int compare(size_type, size_type, charT*) const; int compare(charT*) const; int compare(size_type, size_type, const charT*, size_type) const; }; // Nonmember Operators template <class charT, class traits, class Allocator> basic_string operator+(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> basic_string operator+(const charT*, const basic_string&); template <class charT, class traits, class Allocator> basic_string operator+(charT, const basic_string&); template <class charT, class traits, class Allocator> basic_string operator+(const basic_string&, const charT*); template <class charT, class traits, class Allocator> basic_string operator+(const basic_string&, charT); template <class charT, class traits, class Allocator> bool operator==(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator==(const charT*, const basic_string&); template <class charT, class traits , class Allocator> bool operator==(const basic_string&, const charT*); template <class charT, class traits, class Allocator> bool operator<(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator<(const charT*, const basic_string&); template <class charT, class traits, class Allocator> bool operator<(const basic_string&, const charT*); template <class charT, class traits, class Allocator> bool operator!=(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator!=(const charT*, const basic_string&); template <class charT, class traits, class Allocator> bool operator!=(const basic_string&, const charT*); template <class charT, class traits, class Allocator> bool operator>(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator>(const charT*, const basic_string&); template <class charT, class traits, class Allocator> bool operator>(const basic_string&, const charT*); template <class charT, class traits, class Allocator> bool operator<=(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator<=(const charT*, const basic_string&); template <class charT, class traits, class Allocator> bool operator<=(const basic_string&, const charT*); template <class charT, class traits, class Allocator> bool operator>=(const basic_string&, const basic_string&); template <class charT, class traits, class Allocator> bool operator>=(const charT*, const basic_string&); template <class charT, class traits, class Allocator> bool operator>= (const basic_string&, const charT*); template <class charT, class traits, class Allocator> void swap(basic_string<charT,traits,Allocator>& a, basic_string<charT,traits,Allocator>& b); template<class charT, class traits, class Allocator> basic_istream<charT, traits>& operator>>(istream&, basic_string&); template <class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(ostream&, const basic_string&); template <class Stream, class charT,class traits, class Allocator> basic_istream<charT, traits>& getline(Stream&, basic_string&, charT); }
In all cases, the Allocator parameter is used for storage management.
explicit basic_string (const Allocator& a = Allocator());
The default constructor. Creates a basic_string with the following effects:
data() |
a non-null pointer that is copyable and can have 0 added to it |
size() |
0 |
capacity() |
an unspecified value |
basic_string (const basic_string<T, traits, Allocator>& str);
Creates a string that is a copy of str.
basic_string (const basic_string& str, size_type pos, size_type n= npos, const allocator& a=allocator());
Creates a string of pos<=size() and determines length rlen of the initial string value as the smaller of n and str.size() - pos. This has the following effects:
data() |
points to the first element of an allocated copy of rlen elements of the string controlled by str beginning at position pos |
size() |
rlen |
capacity() |
a value at least as large as size() |
get_allocator() |
str.get_allocator() |
An out_of_range exception is thrown if pos > str.size().
basic_string (const charT* s, size_type n, const Allocator& a = Allocator());
Creates a string that contains the first n characters of s. s must not be a NULL pointer. The effects of this constructor are:
data() |
points to the first element of an allocated copy of the array whose first element is pointed to by s |
size() |
n |
capacity() |
a value at least as large as size() |
A length_error exception is thrown if n == npos.
basic_string (const charT * s, const Allocator& a = Allocator());
Constructs a string containing all characters in s up to, but not including, a traits::eos() character. s must not be a null pointer. The effects of this constructor are:
data() |
points to the first element of an allocated copy of the array whose first element is pointed to by s |
size() |
traits::length(s) |
capacity() |
a value at least as large as size() |
basic_string (size_type n, charT c, const Allocator& a = Allocator());
Constructs a string containing n repetitions of c. A length_error exception is thrown if n == npos. The effects of this constructor are:
data() |
points to the first element of an allocated array of n elements, each storing the initial value c |
size() |
n |
capacity() |
a value at least as large as size() |
template <class InputIterator> basic_string (InputIterator start, InputIterator finish, const Allocator& a = Allocator());
Creates a basic_string of length finish - start filled with all values obtained by dereferencing the InputIterators on the range [start, finish). The effects of this constructor are:
data() |
points to the first element of an allocated copy of the elements in the range [start,finish) |
size() |
distance between start and finish |
capacity() |
a value at least as large as size() |
~basic_string ();
Releases any allocated memory for this basic_string.
basic_string& operator=(const basic_string& str);
Sets the contents of this string to be the same as str. The effects of operator= are:
data() |
points to the first element of an allocated copy of the array whose first element is pointed to by str.size() |
size() |
str.size() |
capacity() |
a value at least as large as size() |
basic_string& operator=(const charT * s);
Sets the contents of this string to be the same as s up to, but not including, the traits::eos() character.
basic_string& operator=(charT c);
Sets the contents of this string to be equal to the single charT c.
const_reference operator[](size_type pos) const; reference operator[](size_type pos);
If pos < size(), returns the element at position pos in this string. If pos == size(), the const variation returns charT(), the behavior of the non-const variation is undefined. The reference returned by either variation is invalidated by any call to c_str(), data(), or any non-const member function for the object.
basic_string& operator+=(const basic_string& s); basic_string& operator+=(const charT* s); basic_string& operator+=(charT c);
Concatenates a string onto the current contents of this string. The second member operator uses traits::length() to determine the number of elements from s to add. The third member operator adds the single character c. All return a reference to this string after completion.
iterator begin(); const_iterator begin() const;
Returns an iterator initialized to the first element of the string.
iterator end(); const_iterator end() const;
Returns an iterator initialized to the position after the last element of the string.
reverse_iterator rbegin(); const_reverse_iterator rbegin() const;
Returns an iterator equivalent to reverse_iterator(end()).
reverse_iterator rend(); const_reverse_iterator rend() const;
Returns an iterator equivalent to reverse_iterator(begin()).
allocator_type get_allocator() const;
Returns a copy of the allocator used by self for storage management.
basic_string& append(const basic_string& s, size_type pos, size_type npos); basic_string& append(const basic_string& s); basic_string& append(const charT* s, size_type n); basic_string& append(const charT* s); basic_string& append(size_type n, charT c ); template<class InputIterator> basic_string& append(InputIterator start, InputIterator finish);
Appends another string to the end of this string.
The first variation appends the lesser of n and s.size() - pos characters of s, beginning at position pos, to this string. It throws an out_of_range exception if pos > str.size().
The second variation appends s as in append (s,0,npos).
The third variation appends n characters of the array pointed to by s.
The fourth variation appends elements from the array pointed to by s up to, but not including, the null character specified by charT().
The fifth variation appends n repetitions of c.
The final variation appends the elements specified in the range [start, finish).
All functions throw a length_error exception if the resulting lengths exceed max_size(). All return a reference to this string after completion.
void push_back(charT c);
Equivalent to append(static_cast<size_type>(1), c).
basic_string& assign(const basic_string& s); basic_string& assign(const basic_string& s, size_type pos, size_type n); basic_string& assign(const charT* s, size_type n); basic_string& assign(const charT* s); basic_string& assign(size_type n, charT c ); template<class InputIterator> basic_string& assign(InputIterator start, InputIterator finish);
Replaces the value of this string with the value of another. All variations of the function assign values to this string.
The first variation assigns the lesser of n and s.size() - pos characters of s, beginning at position pos. It throws an out_of_range exception if pos > str.size().
The second variation assigns s as if by assign(s,0,npos).
The third variation assigns n characters of the array pointed to by s.
The fourth variation assigns elements from the array pointed to by s up to, but not including, the null character specified by charT().
The fifth variation assigns one or n repetitions of c.
The final variation assigns the members specified by the range [start, finish).
All functions throw a length_error exception if the resulting lengths exceed max_size(). All return a reference to this string after completion.
const_reference at(size_type pos) const; reference at(size_type pos);
If pos < size(), returns the element at position pos in this string. Otherwise, throws an out_of_range exception.
size_type capacity() const;
Returns the current storage capacity of the string. This is guaranteed to be at least as large as size().
void clear();
Removes all elements in this string.
int compare(const basic_string& str) const;
Performs lexicographical comparison of elements controlled by *this against those controlled by str. Calls:
traits_type::compare(data(), str.data(), std::min(size(), str.size())
and returns the nonzero value if the function returns nonzero. Otherwise, returns:
<0 if size() < str.size() 0 if size() == str.size() >0 if size() > str.size()
int compare(size_type pos1, size_type n1, const basic_string& str) const; int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2) const; int compare(const char_type* s) const; int compare(size_type pos, size_type n1, const char_type* s) const; int compare(size_type pos, size_type n1, const char_type* s, size_type n2) const;
Returns the result of a lexicographical comparison between elements of this string and a given comparison string. The members return, respectively:
basic_string(*this,pos1,n1).compare(str) basic_string(*this,pos1,n1).compare(basic_string (str, pos2, n2)) *this.compare(basic_string(s)) basic_string(*this,pos,n1).compare(basic_string(s)) basic_string(*this,pos,n1).compare(basic_string(s,n2))
size_type copy(charT* s, size_type n, size_type pos = 0) const;
The lesser of n and size() - pos elements of this string, starting at position pos, are copied into the array pointed to by s. No terminating null is appended to s. An out_of_range exception is thrown if pos > size().
const charT* c_str() const; const charT* data() const;
Returns a pointer to the initial element of an array whose first size() elements are copies of the elements in this string. For the c_str() function, a charT() element is appended to the end. The elements of the array may not be altered, and the returned pointer is only valid until a non-const member function of this string is called. If size() is zero, the data() function returns a non-NULL pointer.
bool empty() const;
Returns size() == 0.
basic_string& erase(size_type pos = 0, size_type n = npos); iterator erase(iterator p); iterator erase(iterator start, iterator finish);
This function removes elements from the string, collapsing the remaining elements, as necessary, to remove any space left empty. Returns a reference to the string after completion.
The first variation of the function removes the smaller of n and size() - pos starting at position pos. An out_of_range exception is thrown if pos > size().
For the second variation, p must be a valid iterator on the string, and the function removes the character referred to by p. The returned iterator refers to the element that preceded the first removed element, or end() if such an element does not exist.
For the last variation, both start and finish must be valid iterators on the string, and the function removes the characters defined by the range [start, finish). The returned iterator refers to the element that preceded the first removed element, or end() if such an element does not exist.
size_type find(const basic_string& str, size_type pos = 0) const;
Searches for the first occurrence of the substring specified by str in this string, starting at position pos. If found, it returns the index of the first character of the matching substring. If not found, returns npos. Equality is defined by traits::eq().
size_type find(const charT* s, size_type pos, size_type n) const; size_type find(const charT* s, size_type pos = 0) const; size_type find(charT c, size_type pos = 0) const;
Searches for the first sequence of characters in this string that match a specified string. The variations of this function return, respectively:
find(basic_string(s,n), pos) find(basic_string(s), pos) find(basic_string(1, c), pos)
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const;
Searches for the first element of this string at or after position pos that is not equal to any element of str. If found, find_first_not_of() returns the index of the nonmatching character. If all the characters match, the function returns npos. Equality is defined by traits::eq().
size_type find_first_not_of (const charT* s, size_type pos, size_type n) const; size_type find_first_not_of (const charT* s, size_type pos = 0) const; size_type find_first_not_of(charT c, size_type pos = 0) const;
Searches for the first element in this string at or after position pos that is not equal to any element of a given set of characters. The members return, respectively:
find_first_not_of(basic_string(s,n), pos) find_first_not_of(basic_string(s), pos) find_first_not_of(basic_string(1, c), pos)
size_type find_first_of(const basic_string& str, size_type pos = 0) const;
Searches for the first occurrence at or after position pos of any element of str in this string. If found, the index of this matching character is returned. If not found, npos is returned. Equality is defined by traits::eq().
size_type find_first_of(const charT* s, size_type pos, size_type n) const; size_type find_first_of(const charT* s, size_type pos = 0) const; size_type find_first_of(charT c, size_type pos = 0) const;
Searches for the first occurrence in this string of any element in a specified string. The find_first_of() variations return, respectively:
find_first_of(basic_string(s,n), pos) find_first_of(basic_string(s), pos) find_first_of(basic_string(1, c), pos)
size_type find_last_not_of(const basic_string& str, size_type pos = npos) const;
Searches for the last element of this string at or before position pos that is not equal to any element of str. If find_last_not_of() finds a non-matching element, it returns the index of the character. If all the elements match, the function returns npos. Equality is defined by traits::eq().
size_type find_last_not_of(const charT* s, size_type pos, size_type n) const; size_type find_last_not_of(const charT* s, size_type pos = npos) const; size_type find_last_not_of(charT c, size_type pos = npos) const;
Searches for the last element in this string at or before position pos that is not equal to any element of a given set of characters. The members return, respectively:
find_last_not_of(basic_string(s,n), pos) find_last_not_of(basic_string(s), pos) find_last_not_of(basic_string(1, c), pos)
size_type find_last_of(const basic_string& str, size_type pos = npos) const;
Searches for the last occurrence of any element of str at or before position pos in this string. If found, find_last_of() returns the index of the matching character. If not found, find_last_of() returns npos. Equality is defined by traits::eq().
size_type find_last_of(const charT* s, size_type pos, size_type n) const; size_type find_last_of(const charT* s, size_type pos = npos) const; size_type find_last_of(charT c, size_type pos = npos) const;
Searches for the last occurrence in this string of any element in a specified string. The members return, respectively:
find_last_of(basic_string(s,n), pos) find_last_of(basic_string(s), pos) find_last_of(basic_string(1, c), pos)
basic_string& insert(size_type pos1, const basic_string& s); basic_string& insert(size_type pos, const basic_string& s, size_type pos2 = 0, size_type n = npos); basic_string& insert(size_type pos, const charT* s, size_type n); basic_string& insert(size_type pos, const charT* s); basic_string& insert(size_type pos, size_type n, charT c);
Inserts additional elements at position pos in this string. All of the variants of this function throw an out_of_range exception if pos > size(). All variants also throw a length_error if the resulting strings exceed max_size(). Elements of this string are moved apart as necessary to accommodate the inserted elements. All return a reference to this string after completion.
The second variation inserts the lesser of n and s.size() - pos2 characters of s, beginning at position pos2 in this string. This variation throws an out_of_range exception if pos2 > s.size().
The third variation inserts n characters of the array pointed to by s.
The fourth variation inserts elements from the array pointed to by s up to, but not including, the null character specified by charT().
The fifth variation inserts n repetitions of c.
iterator insert(iterator p, charT); void insert(iterator p, size_type n, charT c); template<class InputIterator> void insert(iterator p, InputIterator start, InputIterator finish);
Inserts additional elements in this string immediately before the character referred to by p. All of these variations of insert() require that p is a valid iterator on this string.
The first variation inserts a copy of c, and returns an iterator that refers to the new character in this string.
The second variation inserts n repetitions of c.
The third variation inserts characters in the range [start, finish).
size_type length() const;
Returns the number of elements contained in this string.
size_type max_size() const;
Returns the maximum possible size of the string.
size_type rfind(const basic_string& str, size_type pos = npos) const;
Searches for the last occurrence of the substring specified by str in the string, where the index of the first character of the substring is less than pos. If found, the index of the first character that matches substring is returned. If not found, npos is returned. Equality is defined by traits::eq().
size_type rfind(const charT* s, size_type pos, size_type n) const; size_type rfind(const charT* s, size_type pos = npos) const; size_type rfind(charT c, size_type pos = npos) const;
Searches for the last sequence of characters in this string matching a specified string. The rfind variations return, respectively:
rfind(basic_string(s,n), pos) rfind(basic_string(s), pos) rfind(basic_string(1, c), pos)
basic_string& replace(size_type pos, size_type n1, const basic_string& s); basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2); basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2); basic_string& replace(size_type pos, size_type n1, const charT* s); basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);
The replace() function replaces selected elements of this string with an alternate set of elements. All of these variations insert the new elements in place of n1 elements in this string, starting at position pos. They each throw an out_of_range exception if pos1 > size() and a length_error exception if the resulting string size exceeds max_size().
The second variation replaces elements of the original string with n2 characters from string s starting at position pos2. It throws the out_of_range exception if pos2 > s.size().
The third variation of the function replaces elements in the original string with n2 elements from the array pointed to by s.
The fourth variation replaces elements in the string with elements from the array pointed to by s, up to, but not including, the null character specified by charT().
The fifth variation replaces n elements with n2 repetitions of character c.
basic_string& replace(iterator i1, iterator i2, const basic_string& str); basic_string& replace(iterator i1, iterator i2, const charT* s, size_type n); basic_string& replace(iterator i1, iterator i2, const charT* s); basic_string& replace(iterator i1, iterator i2, size_type n, charT c); template<class InputIterator> basic_string& replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2);
Replaces selected elements of this string with an alternative set of elements. All of these variations of replace require iterators i1 and i2 to be valid iterators on this string. The elements specified by the range [i1, i2) are replaced by the new elements.
The first variation replaces all members in str.
The second variation starts at position i1, and replaces the next n characters with n characters of the array pointed to by s.
The third variation replaces string elements with elements from the array pointed to by s up to, but not including, a charT() character.
The fourth variation replaces string elements with n repetitions of c.
The last variation replaces string elements with the members specified in the range [j1, j2).
void reserve(size_type res_arg=0);
Assures that the storage capacity is at least res_arg. Throws a length_error exception if res_arg > max_size().
void resize(size_type n, charT c); void resize(size_type n);
Changes the capacity of this string to n. If the new capacity is smaller than the current size of the string, then the string is truncated. If the capacity is larger, then the string is padded with c characters. The latter resize() member pads the string with default characters specified by charT(). Throws a length_error exception if n > max_size().
size type size()const;
Returns the number of elements contained in this string.
basic_string substr(size_type pos = 0, size_type n = npos) const;
Returns a string composed of copies of the lesser of n and size() - pos characters in this string starting at index pos. Throws an out_of_range exception if pos > size().
void swap(basic_string& s);
Swaps the contents of this string with the contents of s.
template<class charT, class traits, class Allocator> basic_string<charT, traits allocator> operator+(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a string of length lhs.size() + rhs.size(), where the first lhs.size() elements are copies of the elements of lhs, and the next rhs.size() elements are copies of the elements of rhs.
template<class charT, class traits, class Allocator> basic_string<charT, traits allocator> operator+(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> basic_string<charT, traits allocator> operator+(charT lhs, const basic_string<charT, traits allocator> & rhs); template<class charT, class traits, class Allocator> basic_string<charT, traits allocator> operator+(const basic_string<charT, traits allocator> &lhs, const charT* rhs); template<class charT, class traits, class Allocator> basic_string<charT, traits allocator> operator+(const basic_string<charT, traits allocator> &lhs, charT rhs);
Returns a string that represents the concatenation of two string-like entities. These functions return, respectively:
basic_string(lhs) + rhs basic_string(1, lhs) + rhs lhs + basic_string(rhs) lhs + basic_string(1, rhs)
template<class charT, class traits, class Allocator> bool operator==(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value of true if lhs and rhs are equal, and false if they are not. Equality is defined by the compare() member function.
template<class charT, class traits, class Allocator> bool operator==(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator==(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value indicating whether lhs and rhs are equal. Equality is defined by the compare() member function. These functions return, respectively:
basic_string(lhs) == rhs lhs == basic_string(rhs)
template<class charT, class traits, class Allocator> bool operator!=(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value representing the inequality of lhs and rhs. Inequality is defined by the compare() member function.
template<class charT, class traits, class Allocator> bool operator!=(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator!=(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value representing the inequality of lhs and rhs. Inequality is defined by the compare() member function. The functions return, respectively:
basic_string(lhs) != rhs lhs != basic_string(rhs)
template<class charT, class traits, class Allocator> bool operator<(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value representing the lexicographical less-than relationship of lhs and rhs. Less-than is defined by the compare() member.
template<class charT, class traits, class Allocator> bool operator<(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator<(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value representing the lexicographical less-than relationship of lhs and rhs. Less-than is defined by the compare() member function. These functions return, respectively:
basic_string(lhs) < rhs lhs < basic_string(rhs)
template<class charT, class traits, class Allocator> bool operator>(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value representing the lexicographical greater-than relationship of lhs and rhs. Greater-than is defined by the compare() member function.
template<class charT, class traits, class Allocator> bool operator>(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator>(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value representing the lexicographical greater-than relationship of lhs and rhs. Greater-than is defined by the compare() member. The functions return, respectively:
basic_string(lhs) > rhs lhs > basic_string(rhs)
template<class charT, class traits, class Allocator> bool operator<=(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value representing the lexicographical less-than-or-equal relationship of lhs and rhs. Less-than-or-equal is defined by the compare() member function.
template<class charT, class traits, class Allocator> bool operator<=(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator<=(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value representing the lexicographical less-than-or-equal relationship of lhs and rhs. Less-than-or-equal is defined by the compare() member function. These functions return, respectively:
basic_string(lhs) <= rhs lhs <= basic_string(rhs)
template<class charT, class traits, class Allocator> bool operator>=(const basic_string<charT, traits allocator> &lhs, const basic_string<charT, traits allocator> &rhs);
Returns a boolean value representing the lexicographical greater-than-or-equal relationship of lhs and rhs. Greater-than-or-equal is defined by the compare() member function.
template<class charT, class traits, class Allocator> bool operator>=(const charT* lhs, const basic_string<charT, traits allocator> &rhs); template<class charT, class traits, class Allocator> bool operator>=(const basic_string<charT, traits allocator> &lhs, const charT* rhs);
Returns a boolean value representing the lexicographical greater-than-or-equal relationship of lhs and rhs. Greater-than-or-equal is defined by the compare() member. The functions return, respectively:
basic_string(lhs) >= rhs lhs >= basic_string(rhs)
template <class charT, class traits, class Allocator> void swap(basic_string<charT,traits,Allocator>& a, basic_string<charT,traits,Allocator>& b);
Swaps the contents of a and b by calling a's swap function on b.
template<class charT, class traits, class Allocator> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits allocator> &str);
All elements read from the stream is, except the delimiter, are placed in str. After the read, the function returns is.
template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream <charT, traits>& os, const basic_string<charT, traits allocator> &str);
Writes all elements of str to os in order from first to last. After the write, the function returns os.
template <class Stream, class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits> is, basic_string<charT, traits allocator> &str, charT delim);
An unformatted input function that extracts characters from is into str until npos - 1 characters are read, the end of the input sequence is reached, or the character read is delim.
// // string.cpp // #include <string> #include <iostream> int main () { #ifndef _RWSTD_NO_NAMESPACE using namespace std; #endif string test; // Type in a string over five characters long. while (test.empty() || test.size() < 5) { cout << "Type a string between 5 and 100 characters long. " << endl; cin >> test; } // Try operator[] access. cout << "Changing the third character from " << test[2] << " to * " << endl; test[2] = '*'; cout << "now it's: " << test << endl << endl; // Try the insertion member function. test.insert(test.size() / 2, "(the middle is here!)"); cout << "Identifying the middle: " << test << endl << endl; // Try replacement. test.replace(test.find("middle",0), 6, "center"); cout << "I didn't like the word 'middle', so instead, " << "I'll say: " << endl << test << endl; return 0; } Program output:
Type a string between 5 and 100 characters long. roguewave Changing the third character from g to * now its: ro*uewave Identifying the middle: ro*u(the middle is here!)ewave I didn't like the word 'middle', so instead, I'll say: ro*u(the center is here!)ewave
ISO/IEC 14882:1998 -- International Standard for Information Systems -- Programming Language C++, Section 21.3


Dr. Norman Borlaug
Timeline of Dr. Borlaug's life:
- 1914 - Born March 25 in Cresco, Iowa, USA
- 1937 - Receives B.S in Forestry from the University of Minnesota and worked for the US Forest Service
- 1937 - Married wife of 69 years, Margaret Gibson
- 1942 - Receives Ph.D in plant pathology and genetics from the University of Minnesota
- 1964 - Made director of the International Wheat Improvement Program at El Batán, Texcoco
- 1970 - Awarded the Nobel Peace Price on December 10
- 1981 - Became founding member of the World Cultural Council
- 1984 - Began teaching and conducting research at Texas A&M University
- 1986 - Created the World Food Prize
- 2009 - Dies of lymphoma on September 12 at the age of 95
For more information about Dr. Borlaug, visit his Wikipedia page here!


Thumbnails are uploaded files containing photos of the printed asset or rendered images of the 3D model.


Welcome to indictrans’s documentation!¶
The project aims on adding a state-of-the-art transliteration module for cross transliterations among all Indian languages including English and Urdu.
The module currently supports the following languages:
- Hindi
- Bengali
- Gujarati
- Punjabi
- Malayalam
- Kannada
- Tamil
- Telugu
- Oriya
- Marathi
- Assamese
- Konkani
- Bodo
- Nepali
- Urdu
- English


Unscramble
People often look at me, especially kids. Although I have harmful light, they still look at me until they are blind. I was not used by kids when they are in school or when they do not get good results for their exams. What am I?
Think you figured it out? Click NEXT to reveal the answer.


Salamtak
Sign into your account
Email
Password
Forgot password?
Don't have an account?
Register here
Terms of use.
Privacy policy


Graphical Interface
All the major data structures and intermediate program states can be
viewed graphically using daVinci. The
following screen dumps are intended to represent the range of
possibilities. Graphical tools like these are an indispensible
debugging aid. Each of the dumps below were taken when generating
code for the mandelbrot on the HPPA
architecture. It will be necessary to make netscape fill the size of
the screen to view these easily. Even though some of these graphs
look quite complex, daVinci has several navigational modes
that allow walking to successors, or predecessors, or navigating
through a scaled down map of the graph. The navigational view is
shown as another window, and the view into the graph that is being
displayed is usually outlined in blue.
-
Control Flowgraph after Optimization:
- Each basic block is shown with its dynamic profile and
code before and after a specific optimization. This view
saves having to pour through pages of assembly code listings
-- a tedious and frustrating activity.
- SSA form:
- The generated flow graph is converted to SSA form which
makes many code improvement optimizations easy and efficient.
-
Data Dependency Graph
(may take time to download)
:
-
A graphical view of the data dependency graph and the various
kinds of dependencies decorating the edges, provides a useful clue to
why instructions got rearranged the way they did. The navigational
view helps to control the complexity in the display.
Lal George
Last modified: Fri May 1 10:42:04 EDT 1998


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | package org.apache.commons.io.input; | |
| 18 | ||
| 19 | import static org.apache.commons.io.IOUtils.EOF; | |
| 20 | ||
| 21 | import java.io.FilterReader; | |
| 22 | import java.io.IOException; | |
| 23 | import java.io.Reader; | |
| 24 | import java.nio.CharBuffer; | |
| 25 | ||
| 26 | /** | |
| 27 | * A Proxy stream which acts as expected, that is it passes the method | |
| 28 | * calls on to the proxied stream and doesn't change which methods are | |
| 29 | * being called. | |
| 30 | *
 | |
| 31 | * It is an alternative base class to FilterReader | |
| 32 | * to increase reusability, because FilterReader changes the | |
| 33 | * methods being called, such as read(char[]) to read(char[], int, int). | |
| 34 | * | |
| 35 | */ | |
| 36 | public abstract class ProxyReader extends FilterReader { | |
| 37 | ||
| 38 | /** | |
| 39 | * Constructs a new ProxyReader. | |
| 40 | * | |
| 41 | * @param proxy the Reader to delegate to | |
| 42 | */ | |
| 43 | public ProxyReader(final Reader proxy) { | |
| 44 | super(proxy); | |
| 45 | // the proxy is stored in a protected superclass variable named 'in' | |
| 46 | } | |
| 47 | ||
| 48 | /** | |
| 49 | * Invokes the delegate's read() method. | |
| 50 | * @return the character read or -1 if the end of stream | |
| 51 | * @throws IOException if an I/O error occurs | |
| 52 | */ | |
| 53 | @Override | |
| 54 | public int read() throws IOException { | |
| 55 | try { | |
| 56 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::beforeRead → NO_COVERAGE |
beforeRead(1); |
| 57 | final int c = in.read(); | |
| 58 |
2
1. read : negated conditional → NO_COVERAGE 2. read : removed call to org/apache/commons/io/input/ProxyReader::afterRead → NO_COVERAGE |
afterRead(c != EOF ? 1 : EOF); |
| 59 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return c; |
| 60 | } catch (final IOException e) { | |
| 61 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 62 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return EOF; |
| 63 | } | |
| 64 | } | |
| 65 | ||
| 66 | /** | |
| 67 | * Invokes the delegate's read(char[]) method. | |
| 68 | * @param chr the buffer to read the characters into | |
| 69 | * @return the number of characters read or -1 if the end of stream | |
| 70 | * @throws IOException if an I/O error occurs | |
| 71 | */ | |
| 72 | @Override | |
| 73 | public int read(final char[] chr) throws IOException { | |
| 74 | try { | |
| 75 |
2
1. read : removed call to org/apache/commons/io/input/ProxyReader::beforeRead → SURVIVED 2. read : negated conditional → KILLED |
beforeRead(chr != null ? chr.length : 0); |
| 76 | final int n = in.read(chr); | |
| 77 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::afterRead → SURVIVED |
afterRead(n); |
| 78 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return n; |
| 79 | } catch (final IOException e) { | |
| 80 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 81 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return EOF; |
| 82 | } | |
| 83 | } | |
| 84 | ||
| 85 | /** | |
| 86 | * Invokes the delegate's read(char[], int, int) method. | |
| 87 | * @param chr the buffer to read the characters into | |
| 88 | * @param st The start offset | |
| 89 | * @param len The number of bytes to read | |
| 90 | * @return the number of characters read or -1 if the end of stream | |
| 91 | * @throws IOException if an I/O error occurs | |
| 92 | */ | |
| 93 | @Override | |
| 94 | public int read(final char[] chr, final int st, final int len) throws IOException { | |
| 95 | try { | |
| 96 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::beforeRead → SURVIVED |
beforeRead(len); |
| 97 | final int n = in.read(chr, st, len); | |
| 98 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::afterRead → SURVIVED |
afterRead(n); |
| 99 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return n; |
| 100 | } catch (final IOException e) { | |
| 101 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 102 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return EOF; |
| 103 | } | |
| 104 | } | |
| 105 | ||
| 106 | /** | |
| 107 | * Invokes the delegate's read(CharBuffer) method. | |
| 108 | * @param target the char buffer to read the characters into | |
| 109 | * @return the number of characters read or -1 if the end of stream | |
| 110 | * @throws IOException if an I/O error occurs | |
| 111 | * @since 2.0 | |
| 112 | */ | |
| 113 | @Override | |
| 114 | public int read(final CharBuffer target) throws IOException { | |
| 115 | try { | |
| 116 |
2
1. read : removed call to org/apache/commons/io/input/ProxyReader::beforeRead → SURVIVED 2. read : negated conditional → KILLED |
beforeRead(target != null ? target.length() : 0); |
| 117 | final int n = in.read(target); | |
| 118 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::afterRead → SURVIVED |
afterRead(n); |
| 119 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → SURVIVED |
return n; |
| 120 | } catch (final IOException e) { | |
| 121 |
1
1. read : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 122 |
1
1. read : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return EOF; |
| 123 | } | |
| 124 | } | |
| 125 | ||
| 126 | /** | |
| 127 | * Invokes the delegate's skip(long) method. | |
| 128 | * @param ln the number of bytes to skip | |
| 129 | * @return the number of bytes to skipped or EOF if the end of stream | |
| 130 | * @throws IOException if an I/O error occurs | |
| 131 | */ | |
| 132 | @Override | |
| 133 | public long skip(final long ln) throws IOException { | |
| 134 | try { | |
| 135 |
1
1. skip : replaced return of long value with value + 1 for org/apache/commons/io/input/ProxyReader::skip → NO_COVERAGE |
return in.skip(ln); |
| 136 | } catch (final IOException e) { | |
| 137 |
1
1. skip : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 138 |
1
1. skip : replaced return of long value with value + 1 for org/apache/commons/io/input/ProxyReader::skip → NO_COVERAGE |
return 0; |
| 139 | } | |
| 140 | } | |
| 141 | ||
| 142 | /** | |
| 143 | * Invokes the delegate's ready() method. | |
| 144 | * @return true if the stream is ready to be read | |
| 145 | * @throws IOException if an I/O error occurs | |
| 146 | */ | |
| 147 | @Override | |
| 148 | public boolean ready() throws IOException { | |
| 149 | try { | |
| 150 |
1
1. ready : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return in.ready(); |
| 151 | } catch (final IOException e) { | |
| 152 |
1
1. ready : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 153 |
1
1. ready : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 154 | } | |
| 155 | } | |
| 156 | ||
| 157 | /** | |
| 158 | * Invokes the delegate's close() method. | |
| 159 | * @throws IOException if an I/O error occurs | |
| 160 | */ | |
| 161 | @Override | |
| 162 | public void close() throws IOException { | |
| 163 | try { | |
| 164 |
1
1. close : removed call to java/io/Reader::close → SURVIVED |
in.close(); |
| 165 | } catch (final IOException e) { | |
| 166 |
1
1. close : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 167 | } | |
| 168 | } | |
| 169 | ||
| 170 | /** | |
| 171 | * Invokes the delegate's mark(int) method. | |
| 172 | * @param idx read ahead limit | |
| 173 | * @throws IOException if an I/O error occurs | |
| 174 | */ | |
| 175 | @Override | |
| 176 | public synchronized void mark(final int idx) throws IOException { | |
| 177 | try { | |
| 178 |
1
1. mark : removed call to java/io/Reader::mark → NO_COVERAGE |
in.mark(idx); |
| 179 | } catch (final IOException e) { | |
| 180 |
1
1. mark : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 181 | } | |
| 182 | } | |
| 183 | ||
| 184 | /** | |
| 185 | * Invokes the delegate's reset() method. | |
| 186 | * @throws IOException if an I/O error occurs | |
| 187 | */ | |
| 188 | @Override | |
| 189 | public synchronized void reset() throws IOException { | |
| 190 | try { | |
| 191 |
1
1. reset : removed call to java/io/Reader::reset → NO_COVERAGE |
in.reset(); |
| 192 | } catch (final IOException e) { | |
| 193 |
1
1. reset : removed call to org/apache/commons/io/input/ProxyReader::handleIOException → NO_COVERAGE |
handleIOException(e); |
| 194 | } | |
| 195 | } | |
| 196 | ||
| 197 | /** | |
| 198 | * Invokes the delegate's markSupported() method. | |
| 199 | * @return true if mark is supported, otherwise false | |
| 200 | */ | |
| 201 | @Override | |
| 202 | public boolean markSupported() { | |
| 203 |
1
1. markSupported : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return in.markSupported(); |
| 204 | } | |
| 205 | ||
| 206 | /** | |
| 207 | * Invoked by the read methods before the call is proxied. The number | |
| 208 | * of chars that the caller wanted to read (1 for the {@link #read()} | |
| 209 | * method, buffer length for {@link #read(char[])}, etc.) is given as | |
| 210 | * an argument. | |
| 211 | *
 | |
| 212 | * Subclasses can override this method to add common pre-processing | |
| 213 | * functionality without having to override all the read methods. | |
| 214 | * The default implementation does nothing. | |
| 215 | *
 | |
| 216 | * Note this method is not called from {@link #skip(long)} or | |
| 217 | * {@link #reset()}. You need to explicitly override those methods if | |
| 218 | * you want to add pre-processing steps also to them. | |
| 219 | * | |
| 220 | * @since 2.0 | |
| 221 | * @param n number of chars that the caller asked to be read | |
| 222 | * @throws IOException if the pre-processing fails | |
| 223 | */ | |
| 224 | protected void beforeRead(final int n) throws IOException { | |
| 225 | } | |
| 226 | ||
| 227 | /** | |
| 228 | * Invoked by the read methods after the proxied call has returned | |
| 229 | * successfully. The number of chars returned to the caller (or -1 if | |
| 230 | * the end of stream was reached) is given as an argument. | |
| 231 | *
 | |
| 232 | * Subclasses can override this method to add common post-processing | |
| 233 | * functionality without having to override all the read methods. | |
| 234 | * The default implementation does nothing. | |
| 235 | *
 | |
| 236 | * Note this method is not called from {@link #skip(long)} or | |
| 237 | * {@link #reset()}. You need to explicitly override those methods if | |
| 238 | * you want to add post-processing steps also to them. | |
| 239 | * | |
| 240 | * @since 2.0 | |
| 241 | * @param n number of chars read, or -1 if the end of stream was reached | |
| 242 | * @throws IOException if the post-processing fails | |
| 243 | */ | |
| 244 | protected void afterRead(final int n) throws IOException { | |
| 245 | } | |
| 246 | ||
| 247 | /** | |
| 248 | * Handle any IOExceptions thrown. | |
| 249 | *
 | |
| 250 | * This method provides a point to implement custom exception | |
| 251 | * handling. The default behaviour is to re-throw the exception. | |
| 252 | * @param e The IOException thrown | |
| 253 | * @throws IOException if an I/O error occurs | |
| 254 | * @since 2.0 | |
| 255 | */ | |
| 256 | protected void handleIOException(final IOException e) throws IOException { | |
| 257 | throw e; | |
| 258 | } | |
| 259 | ||
| 260 | } | |
Mutations | ||
| 56 |
1.1 |
|
| 58 |
1.1 2.2 |
|
| 59 |
1.1 |
|
| 61 |
1.1 |
|
| 62 |
1.1 |
|
| 75 |
1.1 2.2 |
|
| 77 |
1.1 |
|
| 78 |
1.1 |
|
| 80 |
1.1 |
|
| 81 |
1.1 |
|
| 96 |
1.1 |
|
| 98 |
1.1 |
|
| 99 |
1.1 |
|
| 101 |
1.1 |
|
| 102 |
1.1 |
|
| 116 |
1.1 2.2 |
|
| 118 |
1.1 |
|
| 119 |
1.1 |
|
| 121 |
1.1 |
|
| 122 |
1.1 |
|
| 135 |
1.1 |
|
| 137 |
1.1 |
|
| 138 |
1.1 |
|
| 150 |
1.1 |
|
| 152 |
1.1 |
|
| 153 |
1.1 |
|
| 164 |
1.1 |
|
| 166 |
1.1 |
|
| 178 |
1.1 |
|
| 180 |
1.1 |
|
| 191 |
1.1 |
|
| 193 |
1.1 |
|
| 203 |
1.1 |


Findings
The geo entities that are mentioned in the web pages are spread all over the world and not just in Europe and USA as you might think. In particular, we can point out the presence of many universities that are those who care more about the subject because of safety reasons and they are also those who are studying it .
Most of the articles about this topic are written by academics of american and english universities indeed.
Another thing to note is the presence of countries like Sweden, that is very relevant because of Pirate Bay and the whole question about it, or the area of California where there are the locations of the majors.
Looking at the amount of geonames for each category it’s evident that university entities are significantly more than the geonames of the other 2 categories.
However considering the amount of mentions the gap between university geonames and country geonames is greatly reduced.
This reflects the fact that mentioned universities are numerous but each one of them is nominated only a few times; mentioned countries are less than universities but they are nominated many times.
This happens because universities are small entities scattered around the world and their voice can be hardly heard in the debate; therefore the authors of the articles prefer to talk referring to big entities like countries which are certainly more obvious.


Term of Services |
| Achiever's Term of Services (to be honest with you, we don't really have one) |
| September 14, Saturday |
| So...like what we told you in the title,we don't have a term of serivces. Why?  So what is this page doing? We are going to educate you about some terms of services you have agreed to without knowing what you have agreed to. |
| Facebook |
| With over a billion users, Facebook is the definitive homepage for many web users. Its terms of service, data use and cookie use policy span more than 14,000 words over eight separate pages and would take even the quickest reader more than two hours to dig through. But what rights have you handed over to Facebook? |
| Specifically for photos and video uploaded to the site, Facebook has a license to use your content in any way it sees fit, with a license that goes beyond merely covering the operation of the service in its current form. Facebook can transfer or sub-license its rights over a user's content to another company or organisation if needed. Facebook's license does not end upon the deactivation or deletion of a user's account, content is only released from this license once all other users that have interacted with the content have also broken their ties with it (for example, a photo or video shared or tagged with a group of friends). |
| Twitter |
| Fast becoming the second social network behind Facebook, Twitter's model for monetising the service has yet to be established, a fact clearly seen in its terms of service. Twitter's terms give it broad scope to use, change and distribute any photos, writing or video posted through Twitter's service, to any other forms of media or distribution method it wishes, including those which Twitter has not yet thought of or developed. Similarly to Facebook, Twitter's license also allows it to pass any of your content to any partner organisations for any reason. |
| Google |
| Making only small waves in the field of social networking, Google+ is probably not the place where most users first agreed to Google's terms of service. Most users probably signed up through one of Google's many online services like Gmail, Google Maps or Google Drive. Luckily Google has a modest set of terms when it comes to user's content, restricting its use of such content only for "the limited purpose of operating, promoting, and improving our Services, and to develop new ones." |
| Dropbox |
| The free file storage service that promises to 'simplify your life' takes only the smallest liberties with its user's content and rights. Dropbox limits their use of your data "solely to provide the services... no matter how the services change, we won't share your content with others..." These permissions do extend to allowing Dropbox to share user's data with "trusted third parties" but again, only in order to provide their existing services. |
| Hope you have learned something. Enjoy the app and work hard! Carpe Diem! :-)
|


About Detrogames
Detrogames is a free online games library for anyone to use. We have no ingame ads or distractions. All of our games are added with permission from the creators, unlike other sites. Absolutely no games require you to pay for anything. Have fun playing our variety of games for free!
What is a Detrogames Original?
A Detrogames Original is a game made by the DetroGames Team.
Links


To understand what we're going to show it's necessary to become familiar with some concepts. The first thing we need to know is what are Unmanaged code and Managed code and how they differ.
Unmanaged code
When we execute a binary in native C/C++, we are working with unmanaged code. This kind of code has the peculiarity it's just get loaded in memory by the OS and gets executed. Everything else depends on the guy who coded the program.
What is "everything else"? Things like memory management or security checks. For example, if a buffer overflow exists in X function is your problem my friend.
Managed code
In contrast with unmanaged, we are working with managed code when we program something using the .NET Framework. The basic difference it's just that .NET offers an enviroment in execution time called Common Language Runtime (CLR). The CLR will compile and execute our managed code even taking care of things like managing memory, perform security checks and so on.
Well, among other things, the CLR offers us the opportunity to use something called Profiling
Profiling
In the profiling context, a profiler is kind of a form of dynamic program analysis that measures thinkgs like the space or time complexity of a program. A CLR profiler is in fact a runtime DLL library loaded by the CLR with which it communicates through an API
So when a managed process is started, the CLR will check if any of the profiler env variables are set and if so, load the specified profiler DLL. (Kind of like LD_PRELOAD in Linux!)
COR_ENABLE_PROFILING --> 1 to enable the profiler, 0 to disable.
COR_PROFILER --> If COR_ENABLE_PROFILING is 1 then CLR check the CLSID/ProgID of the profiler.
COR_PROFILER_PATH --> Path to the profiler's DLL.
As a curiosity, in the .bat for users "not admin" of Invisi-Shell, instead of using COR_PROFILER_PATH, a series of entries in the registry HKCU are created. This is not necessary for the latest versions of NET.
More info:
https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/profiling/profiling-overview
https://docs.microsoft.com/en-us/dotnet/framework/unmanaged-api/profiling/setting-up-a-profiling-environment


---
layout: post
title: What's up
date: '2007-06-08T08:38:00.000-07:00'
author: Kris Rice
tags:
modified_time: '2008-12-08T13:13:20.202-08:00'
thumbnail: http://4.bp.blogspot.com/_HTPuwjEAZfk/Rml4LlUGalI/AAAAAAAAADM/RfYITLcuEhQ/s72-c/ishot-2.png
blogger_id: tag:blogger.com,1999:blog-37621059.post-4543546602494234930
blogger_orig_url: http://krisrice.blogspot.com/2007/06/whats-up.html
---
I forgot I added a real simple way to see what DBs are up in sqldev a while back. If in the worksheet, you run a command, F5 (run script), "pingall" it will do a tnsping of all the connections defined and report back. From this screenshot you'll notice most of my DBs are down. My plan was to hook up an indicator in the tree for down database but never got it well tested.


@(todos: java.util.ArrayList[models.Todo]) @main("Todos") {
Created by Craig Davies with Scala and the Play Framework