La Grande illusion (1937)
Grade: 81
"The Grande Illusion" is a French film set during World War I. While the main subject is the plight of French prisoners of war held in Germany, the film also explores themes of class conflict, and the desire to be free and living in one's own country.
Marechal (Jean Gabin) and de Boeldieu (Pierre Fresnay) are pilots shot down by German aristocrat von Rauffenstein (Erich von Stroheim). Taken prisoner, the pilots are introduced to Rauffenstein, who proves a gracious host. They are soon taken to a POW camp in Germany, where prisoners fight the tedium by plotting escapes and even by cross-dressing. Eventually, Marechal and de Boeldieu, along with Jewish officer Rosenthal (Marcel Dalio) are re-united with Rauffenstein, now a POW camp commander afflicted with war injuries.
de Boeldieu must decide whether his loyalties lie with France or with gentlemanly snob von Rauffenstein. Marechal must reconcile both his prejudice against Rosenthal and his working class contempt for white-gloved de Boeldieu. "The Grand Illusion" also questions whether aristocrats can survive in the new order emerging from the tumultous world war.
"The Grand Illusion" is considered by some to be the best film ever made. While undeniably an excellent film, IMHO it does not rank among the very best films. It has been called anti-war, but it doesn't convey that message as well as "All Quiet on the Western Front" and "Paths of Glory", or even "Full Metal Jacket". The taking, losing and re-capaturing of French cities, while implying the useless waste of trench warfare, is depicted through second-hand information, which lacks the visual impact of seeing soldiers suffering in the field. von Stroheim's character is remarkably deep and sympathetic, but this does not apply to the French officers. Their characters, while perfectly credible, aren't as deep. Marechal is most interesting when conversing with a cow, and Rosenthal when in despair over being abandoned by Marechal in the German countryside. At other times, Marechal seems simply an opportunist, albeit an honest one.
<EMAIL_ADDRESS>http://members.tripod.com/~Brian_Koller/movies.html
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


this website is no longer maintained. for a better and maintained version, click here.
honkers, a discord goose
honkers is a goose discord bot developed by inkthought labs in 2020. it acts like a goose - aggressive, funny and annoying. it also makes sassy remarks. go add it to your server now!


Here is the main screen which will present itself once the application loads. On it you will be able to view the winning numbers for your states lottery, which will update in real time as the day progresses. Below will be a more in-depth look into the interface:
The top half of the screen displays the location, date and the winning numbers for that specific time of day. Beyond that there are several other features to be utilized when viewing and generating picks.
Using the left and right arrows on the screen you can navigate between different dates. This will allow you to see previously generated numbers and numbers which were drawn for that date and time.
This will allow you to generate lotto numbers based off of winning numbers from a specified time and date. Once you make your selection then you can specify which date and time in which these numbers will be used.
This will allow take you to a separate screen which will allow you to view the numbers which you have generated for that time of day.
Used to signify if you have a winning number from your generated picks.
Used to signify when you have generated numbers for that time and date.
Used to signify if there are no winning numbers/when something is unselected.
Used to signify when you have a specific time of day selected.
You can select and see the winning numbers for the time of day in this section of the interface, the tab color on the right will signify if there were generated, winning or no winning numbers.
Here is the main screen which will present itself once the application loads. On it you will be able to view the winning numbers for your states lottery, which will update in real time as the day progresses. Below will be a more in-depth look into the interface:
The top half of the screen displays the location, date and the winning numbers for that specific time of day. Beyond that there are several other features to be utilized when viewing and generating picks.
Using the left and right arrows on the screen you can navigate between different dates. This will allow you to see previously generated numbers and numbers which were drawn for that date and time.
This will allow you to generate lotto numbers based off of winning numbers from a specified time and date. Once you make your selection then you can specify which date and time in which these numbers will be used.
This will allow take you to a separate screen which will allow you to view the numbers which you have generated for that time of day.
Used to signify if you have a winning number from your generated picks.
Used to signify when you have generated numbers for that time and date.
Used to signify if there are no winning numbers/when something is unselected.
Used to signify when you have a specific time of day selected.
You can select and see the winning numbers for the time of day in this section of the interface, the tab color on the right will signify if there were generated, winning or no winning numbers.


Explore
Type in the name of an area in the top right-hand bar or click on an area in the map
Visualise
Scroll down to view statistics and charts about young people and the context in which they live
Compare
Compare any two areas by typing a second area in the bar below the map


- authors
- Jason Lowe-Power
Adding parameters to SimObjects and more events
One of the most powerful parts of gem5’s Python interface is the ability
to pass parameters from Python to the C++ objects in gem5. In this
chapter, we will explore some of the kinds of parameters for SimObjects
and how to use them building off of the simple HelloObject
from the
previous chapters <events-chapter>.
Simple parameters
First, we will add parameters for the latency and number of times to
fire the event in the HelloObject
. To add a parameter, modify the
HelloObject
class in the SimObject Python file
(src/learning_gem5/HelloObject.py
). Parameters are set by adding new
statements to the Python class that include a Param
type.
For instance, the following code as a parameter time_to_wait
which is
a “Latency” parameter and number_of_fires
which is an integer
parameter.
``` {.sourceCode .python} class HelloObject(SimObject): type = ‘HelloObject’ cxx_header = “learning_gem5/hello_object.hh”
time_to_wait = Param.Latency("Time before firing the event")
number_of_fires = Param.Int(1, "Number of times to fire the event before "
"goodbye") ```
Param.<TypeName>
declares a parameter of type TypeName
. Common types
are Int
for integers, Float
for floats, etc.
Each parameter declaration takes one or two parameters. When given two
parameters (like number_of_fires
above), the first parameter is the
default value for the parameter. In this case, if you instantiate a
HelloObject
in your Python config file without specifying any value
for number_of_fires, it will take the default value of 1.
The second parameter to the parameter declaration is a short description
of the parameter. This must be a Python string. If you only specify a
single parameter to the parameter declaration, it is the description (as
for time_to_wait
).
gem5 also supports many complex parameter types that are not just
builtin types. For instance, time_to_wait
is a Latency
. Latency
takes a value as a time value as a string and converts it into simulator
ticks. For instance, with a default tick rate of 1 picosecond
(10\^12 ticks per second or 1 THz), "1ns"
is automatically converted
to 1000. There are other convenience parameters like Percent
,
Cycles
, MemorySize
and many more.
Once you have declared these parameters in the SimObject file, you need
to copy their values to your C++ class in its constructor. The following
code shows the changes to the HelloObject
constructor.
``` {.sourceCode .c++} HelloObject::HelloObject(HelloObjectParams params) : SimObject(params), event(this), myName(params->name), latency(params->time_to_wait), timesLeft(params->number_of_fires) { DPRINTF(Hello, “Created the hello object with the name %s\n”, myName); }
Here, we use the parameter's values for the default values of latency
and timesLeft. Additionally, we store the `name` from the parameter
object to use it later in the member variable `myName`. Each `params`
instantiation has a name which comes from the Python config file when it
is instantiated.
However, assigning the name here is just an example of using the params
object. For all SimObjects, there is a `name()` function that always
returns the name. Thus, there is never a need to store the name like
above.
To the HelloObject class declaration, add a member variable for the
name.
``` {.sourceCode .c++}
class HelloObject : public SimObject
{
private:
void processEvent();
EventWrapper<HelloObject, &HelloObject::processEvent> event;
std::string myName;
Tick latency;
int timesLeft;
public:
HelloObject(HelloObjectParams *p);
void startup();
};
When we run gem5 with the above, we get the following error:
gem5 Simulator System. http://gem5.org
gem5 is copyrighted software; use the --copyright option for details.
gem5 compiled Jan 4 2017 14:46:36
gem5 started Jan 4 2017 14:46:52
gem5 executing on chinook, pid 3422
command line: build/X86/gem5.opt --debug-flags=Hello configs/learning_gem5/part2/run_hello.py
Global frequency set at<PHONE_NUMBER>000 ticks per second
fatal: hello.time_to_wait without default or user set value
This is because the time_to_wait
parameter does not have a default
value. Therefore, we need to update the Python config file
(run_hello.py
) to specify this value.
``` {.sourceCode .python} root.hello = HelloObject(time_to_wait = ‘2us’)
Or, we can specify `time_to_wait` as a member variable. Either option is
exactly the same because the C++ objects are not created until
`m5.instantiate()` is called.
``` {.sourceCode .python}
root.hello = HelloObject()
root.hello.time_to_wait = '2us'
The output of this simple script is the following when running the the
Hello
debug flag.
gem5 Simulator System. http://gem5.org
gem5 is copyrighted software; use the --copyright option for details.
gem5 compiled Jan 4 2017 14:46:36
gem5 started Jan 4 2017 14:50:08
gem5 executing on chinook, pid 3455
command line: build/X86/gem5.opt --debug-flags=Hello configs/learning_gem5/part2/run_hello.py
Global frequency set at<PHONE_NUMBER>000 ticks per second
0: hello: Created the hello object with the name hello
Beginning simulation!
info: Entering event queue @ 0. Starting simulation...
2000000: hello: Hello world! Processing the event! 0 left
2000000: hello: Done firing!
Exiting @ tick<PHONE_NUMBER>3709551615 because simulate() limit reached
You can also modify the config script to fire the event multiple times.
Other SimObjects as parameters
You can also specify other SimObjects as parameters. To demonstrate
this, we are going to create a new SimObject, GoodbyeObject
. This
object is going to have a simple function that says “Goodbye” to another
SimObject. To make it a little more interesting, the GoodbyeObject
is
going to have a buffer to write the message, and a limited bandwidth to
write the message.
First, declare the SimObject in the SConscript file:
``` {.sourceCode .python} Import(‘*’)
SimObject(‘HelloObject.py’) Source(‘hello_object.cc’) Source(‘goodbye_object.cc’)
DebugFlag(‘Hello’)
The new SConscript file can be downloaded
here \<../\_static/scripts/part2/parameters/SConscript\>
Next, you need to declare the new SimObject in a SimObject Python file.
Since the `GoodbyeObject` is highly related to the `HelloObject`, we
will use the same file. You can add the following code to
`HelloObject.py`.
This object has two parameters, both with default values. The first
parameter is the size of a buffer and is a `MemorySize` parameter.
Second is the `write_bandwidth` which specifies the speed to fill the
buffer. Once the buffer is full, the simulation will exit.
``` {.sourceCode .python}
class GoodbyeObject(SimObject):
type = 'GoodbyeObject'
cxx_header = "learning_gem5/goodbye_object.hh"
buffer_size = Param.MemorySize('1kB',
"Size of buffer to fill with goodbye")
write_bandwidth = Param.MemoryBandwidth('100MB/s', "Bandwidth to fill "
"the buffer")
The updated HelloObject.py
file can be downloaded
here <../_static/scripts/part2/parameters/HelloObject.py>
Now, we need to implement the GoodbyeObject
.
``` {.sourceCode .c++} #ifndef LEARNING_GEM5_GOODBYE_OBJECT_HH #define LEARNING_GEM5_GOODBYE_OBJECT_HH
#include
#include “params/GoodbyeObject.hh” #include “sim/sim_object.hh”
class GoodbyeObject : public SimObject { private: void processEvent();
/**
* Fills the buffer for one iteration. If the buffer isn't full, this
* function will enqueue another event to continue filling.
*/
void fillBuffer();
EventWrapper<GoodbyeObject, &GoodbyeObject::processEvent> event;
/// The bytes processed per tick
float bandwidth;
/// The size of the buffer we are going to fill
int bufferSize;
/// The buffer we are putting our message in
char *buffer;
/// The message to put into the buffer.
std::string message;
/// The amount of the buffer we've used so far.
int bufferUsed;
public: GoodbyeObject(GoodbyeObjectParams *p); ~GoodbyeObject();
/**
* Called by an outside object. Starts off the events to fill the buffer
* with a goodbye message.
*
* @param name the name of the object we are saying goodbye to.
*/
void sayGoodbye(std::string name); };
#endif // LEARNING_GEM5_GOODBYE_OBJECT_HH
``` {.sourceCode .c++}
#include "learning_gem5/goodbye_object.hh"
#include "debug/Hello.hh"
#include "sim/sim_exit.hh"
GoodbyeObject::GoodbyeObject(GoodbyeObjectParams *params) :
SimObject(params), event(*this), bandwidth(params->write_bandwidth),
bufferSize(params->buffer_size), buffer(nullptr), bufferUsed(0)
{
buffer = new char[bufferSize];
DPRINTF(Hello, "Created the goodbye object\n");
}
GoodbyeObject::~GoodbyeObject()
{
delete[] buffer;
}
void
GoodbyeObject::processEvent()
{
DPRINTF(Hello, "Processing the event!\n");
fillBuffer();
}
void
GoodbyeObject::sayGoodbye(std::string other_name)
{
DPRINTF(Hello, "Saying goodbye to %s\n", other_name);
message = "Goodbye " + other_name + "!! ";
fillBuffer();
}
void
GoodbyeObject::fillBuffer()
{
// There better be a message
assert(message.length() > 0);
// Copy from the message to the buffer per byte.
int bytes_copied = 0;
for (auto it = message.begin();
it < message.end() && bufferUsed < bufferSize - 1;
it++, bufferUsed++, bytes_copied++) {
// Copy the character into the buffer
buffer[bufferUsed] = *it;
}
if (bufferUsed < bufferSize - 1) {
// Wait for the next copy for as long as it would have taken
DPRINTF(Hello, "Scheduling another fillBuffer in %d ticks\n",
bandwidth * bytes_copied);
schedule(event, curTick() + bandwidth * bytes_copied);
} else {
DPRINTF(Hello, "Goodbye done copying!\n");
// Be sure to take into account the time for the last bytes
exitSimLoop(buffer, 0, curTick() + bandwidth * bytes_copied);
}
}
GoodbyeObject*
GoodbyeObjectParams::create()
{
return new GoodbyeObject(this);
}
The header file can be downloaded here <../_static/scripts/part2/parameters/goodbye_object.hh> and the implementation can be downloaded here <../_static/scripts/part2/parameters/goodbye_object.cc>
The interface to this GoodbyeObject
is simple a function sayGoodbye
which takes a string as a parameter. When this function is called, the
simulator builds the message and saves it in a member variable. Then, we
begin filling the buffer.
To model the limited bandwidth, each time we write the message to the buffer, we pause for the latency it takes to write the message. We use a simple event to model this pause.
Since we used a MemoryBandwidth
parameter in the SimObject
declaration, the bandwidth
variable is automatically converted into
ticks per byte, so calculating the latency is simply the bandwidth times
the bytes we want to write the buffer.
Finally, when the buffer is full, we call the function exitSimLoop
,
which will exit the simulation. This function takes three parameters,
the first is the message to return to the Python config script
(exit_event.getCause()
), the second is the exit code, and the third is
when to exit.
Adding the GoodbyeObject as a parameter to the HelloObject
First, we will also add a GoodbyeObject
as a parameter to the
HelloObject
. To do this, you simply specify the SimObject class name
as the TypeName
of the Param
. You can have a default, or not, just
like a normal parameter.
``` {.sourceCode .python} class HelloObject(SimObject): type = ‘HelloObject’ cxx_header = “learning_gem5/hello_object.hh”
time_to_wait = Param.Latency("Time before firing the event")
number_of_fires = Param.Int(1, "Number of times to fire the event before "
"goodbye")
goodbye_object = Param.GoodbyeObject("A goodbye object") ```
The updated HelloObject.py
file can be downloaded
here <../_static/scripts/part2/parameters/HelloObject.py>
Second, we will add a reference to a GoodbyeObject
to the
HelloObject
class.
``` {.sourceCode .c++} class HelloObject : public SimObject { private: void processEvent();
EventWrapper<HelloObject, &HelloObject::processEvent> event;
/// Pointer to the corresponding GoodbyeObject. Set via Python
const GoodbyeObject* goodbye;
/// The name of this object in the Python config file
const std::string myName;
/// Latency between calling the event (in ticks)
const Tick latency;
/// Number of times left to fire the event before goodbye
int timesLeft;
public: HelloObject(HelloObjectParams *p);
void startup(); }; ```
Then, we need to update the constructor and the process event function
of the HelloObject
. We also add a check in the constructor to make
sure the goodbye
pointer is valid. It is possible to pass a null
pointer as a SimObject via the parameters by using the NULL
special
Python SimObject. We should panic when this happens since it is not a
case this object has been coded to accept.
``` {.sourceCode .c++} #include “learning_gem5/part2/hello_object.hh”
#include “base/misc.hh” #include “debug/Hello.hh”
HelloObject::HelloObject(HelloObjectParams params) : SimObject(params), event(this), goodbye(params->goodbye_object), myName(params->name), latency(params->time_to_wait), timesLeft(params->number_of_fires) { DPRINTF(Hello, “Created the hello object with the name %s\n”, myName); panic_if(!goodbye, “HelloObject must have a non-null GoodbyeObject”); }
Once we have processed the number of event specified by the parameter,
we should call the `sayGoodbye` function in the `GoodbyeObject`.
``` {.sourceCode .c++}
void
HelloObject::processEvent()
{
timesLeft--;
DPRINTF(Hello, "Hello world! Processing the event! %d left\n", timesLeft);
if (timesLeft <= 0) {
DPRINTF(Hello, "Done firing!\n");
goodbye.sayGoodbye(myName);
} else {
schedule(event, curTick() + latency);
}
}
You can find the updated header file here <../_static/scripts/part2/parameters/hello_object.hh> and the implementation file here <../_static/scripts/part2/parameters/hello_object.cc>.
Updating the config script
Lastly, we need to add the GoodbyeObject
to the config script. Create
a new config script, hello_goodbye.py
and instantiate both the hello
and the goodbye objects. For instance, one possible script is the
following.
``` {.sourceCode .python} import m5 from m5.objects import *
root = Root(full_system = False)
root.hello = HelloObject(time_to_wait = ‘2us’, number_of_fires = 5) root.hello.goodbye_object = GoodbyeObject(buffer_size=’100B’)
m5.instantiate()
print “Beginning simulation!” exit_event = m5.simulate() print ‘Exiting @ tick %i because %s’ % (m5.curTick(), exit_event.getCause()) ```
You can download this script here <../_static/scripts/part2/parameters/hello_goodbye.py>
Running this script generates the following output.
gem5 Simulator System. http://gem5.org
gem5 is copyrighted software; use the --copyright option for details.
gem5 compiled Jan 4 2017 15:17:14
gem5 started Jan 4 2017 15:18:41
gem5 executing on chinook, pid 3838
command line: build/X86/gem5.opt --debug-flags=Hello configs/learning_gem5/part2/hello_goodbye.py
Global frequency set at<PHONE_NUMBER>000 ticks per second
0: hello.goodbye_object: Created the goodbye object
0: hello: Created the hello object
Beginning simulation!
info: Entering event queue @ 0. Starting simulation...
2000000: hello: Hello world! Processing the event! 4 left
4000000: hello: Hello world! Processing the event! 3 left
6000000: hello: Hello world! Processing the event! 2 left
8000000: hello: Hello world! Processing the event! 1 left
10000000: hello: Hello world! Processing the event! 0 left
10000000: hello: Done firing!
10000000: hello.goodbye_object: Saying goodbye to hello
10000000: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10152592: hello.goodbye_object: Processing the event!
10152592: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10305184: hello.goodbye_object: Processing the event!
10305184: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10457776: hello.goodbye_object: Processing the event!
10457776: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10610368: hello.goodbye_object: Processing the event!
10610368: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10762960: hello.goodbye_object: Processing the event!
10762960: hello.goodbye_object: Scheduling another fillBuffer in 152592 ticks
10915552: hello.goodbye_object: Processing the event!
10915552: hello.goodbye_object: Goodbye done copying!
Exiting @ tick 10944163 because Goodbye hello!! Goodbye hello!! Goodbye hello!! Goodbye hello!! Goodbye hello!! Goodbye hello!! Goo
You can modify the parameters to these two SimObjects and see how the overall execution time (Exiting @ tick 10944163) changes. To run these tests, you may want to remove the debug flag so there is less output to the terminal.
In the next chapters, we will create a more complex and more useful SimObject, culminating with a simple blocking uniprocessor cache implementation.


Berkeley Wireless Research Center, 2108 Allston Way, Berkeley, CA 94720
taehwan (at) eecs.berkeley.edu
|
CV (last update: 190503)
I am a Ph.D. student at UC Berkeley in EECS working with Vladimir Stojanović in the Berkeley Wireless Research Center (BWRC).
I enjoy designing and analyzing complex systems, and also improving the way people design and analyze such systems. As a member of Integrated Systems Group, I am trying to tackle these problems in the context of integrated opto-electronics. I am currently working on the design of free-space optical systems such as LIDAR and communication links based on integrated electronics-photonics platform.
Ph.D. in Electrical Engineering and Computer Science (Advisor: Vladimir Stojanović)
Thesis: Realization of Integrated Coherent LiDAR
Completed Coursework:
Aug. 2014 - Aug. 2019
B.S. in Electrical and Computer Engineering
B.A. in Economics (Double major)
Mar. 2007 - Feb. 2014
T. Kim*, P. Bhargava*, C. V. Poulton*, J. Notaros, A. Yaacobi, E. Timurdogan, C. Baiocco, N. Fahrenkopf, S. Kruger, T. Ngai, Y. Timalsina, M. R. Watts, V. Stojanović, “A Single-Chip Optical Phased Array in a Wafer-Scale Silicon Photonics / CMOS 3D-Integration Platform," IEEE Journal of Solid-State Circuits (JSSC), 2019. [Invited]
T. Kim*, S. Moon*, K. Xu, “Information-Rich Localization Microscopy through Machine Learning,” Nature Communications, 2019.
P. Bhargava*, T. Kim*, C. V. Poulton*, J. Notaros, A. Yaacobi, E. Timurdogan, C. Baiocco, N. Fahrenkopf, S. Kruger, T. Ngai, Y. Timalsina, M. R. Watts, V. Stojanović, “Fully Integrated Coherent LiDAR in 3D-Integrated Silicon Photonics/65nm CMOS,” IEEE Symposium on VLSI Circuits, 2019.
T. Kim, P. Bhargava, C. V. Poulton, J. Notaros, A. Yaacobi, E. Timurdogan, C. Baiocco, N. Fahrenkopf, S. Kruger, T. Ngai, Y. Timalsina, M. R. Watts, V. Stojanović, “A Single-Chip Optical Phased Array in a 3D-Integrated Silicon Photonics/65nm CMOS Technology,” IEEE International Solid-State Circuits Conference (ISSCC), 2019.
T. Kim, P. Bhargava, V. Stojanović, “Overcoming the Coherence Distance Barrier in Long-Range FMCW LIDAR,” Conference on Lasers and Electro-Optics (CLEO), 2018.
T. Kim, P. Bhargava, V. Stojanović, “Optimal Spectral Estimation and System Trade-Off in Long-Distance Frequency-Modulated Continuous-Wave LIDAR,” IEEE International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2018.
T. Kim, P. Bhargava, V. Stojanović, “A Model Predictive Control Equalization Transmitter for Asymmetric Interfaces in 28nm FDSOI,” IEEE Asian Solid-State Circuits Conference (ASSCC), 2016.
T. Kim, D.-G. Song, S. Youn, J. Park, H. Park, and J. Kim, “Verifying Start-Up Failures in Coupled Ring Oscillators in Presence of Variability Using Predictive Global Optimization,” IEEE/ACM International Conference on Computer-Aided Design (ICCAD), 2013.
J. Kim, J. Lee, D.-G. Song, T. Kim, K.-H. Kim, S. Jung, and S. Youn, “Discretization and Discrimination Methods for Design, Verification, and Testing of Analog/Mixed Signal Circuits,” Custom Integrated Circuits Conference (CICC), 2013.


Tabim
Drag & Drop gp5 file to render as ASCII tabs
Loading Python Code...
Drag gp5 file here...
Download Tab


$title_end = !$is_search ? " for Today" : ""; $page->title($inst_name." Events Calendar: " . $calendars[$_REQUEST['id']]['title'] . $title_end) ->navbar_image('title-calendar') ->breadcrumbs("Browse", "Listing") ->breadcrumb_links(categorysURL()); $page->content_begin(); ?>
".$i." match found:
"); } else if ($i < 30) { echo("".$i." matches were found:
"); } else { echo("The first 30 matches found:
"); } ?>There were no results returned.
"); } else { foreach ($eventFeed as $event) { include("li_item.html"); } } ?> $page->content_end(); ?>


For reward, here is a list of awesome computer scientists!
You want more? Add them yourself!
{{name.name | json}} {{name.city | json}} {{name.district | json}}


{#foreach $T.comments as c}
{$T.c.user}
{$T.c.text}
{$T.c.date}
{$T.c.timestamp}
{$T.c.uuid}
{#if $P.user == $T.c.user}
{#/if}
{#/for}
OpenChatter
userName
Welcome
Post your message below:
Most popular topics
In the last week:
In the last month:
Post your message below:


The need to blur this or that can come up quite often as you try to obtain a particular look or perform some technique like motion blur. Below are just some of ways you can blur your game's imagery.
The box blur or mean filter algorithm is a simple to implement blurring effect. It's fast and gets the job done. If you need more finesse, you can upgrade to a Gaussian blur.
// ...
vec2 texSize = textureSize(colorTexture, 0).xy;
vec2 texCoord = gl_FragCoord.xy / texSize;
int size = int(parameters.x);
if (size <= 0) { fragColor = texture(colorTexture, texCoord); return; }
// ...
The size
parameter controls how blurry the result is. If the size
is zero or less, return the fragment untouched.
The separation
parameter spreads out the blur without having to sample additional fragments. separation
ranges from one to infinity.
// ...
for (int i = -size; i <= size; ++i) {
for (int j = -size; j <= size; ++j) {
// ...
}
}
// ...
Like the outlining technique, the box blur technique uses a kernel/matrix/window centered around the current fragment. The size of the window is size * 2 + 1
by size * 2 + 1
. So for example, with a size
setting of two, the window uses (2 * 2 + 1)^2 = 25
samples per fragment.
// ...
fragColor +=
texture
( colorTexture
, ( gl_FragCoord.xy
+ (vec2(i, j) * separation)
)
/ texSize
);
// ...
To compute the mean or average of the samples in the window, start by loop through the window, adding up each color vector.
To finish computing the mean, divide the sum of the colors sampled by the number of samples taken. The final fragment color is the mean or average of the fragments sampled inside the window.
The box blur uses the mean color of the samples taken. The median filter uses the median color of the samples taken. By using the median instead of the mean, the edges in the image are preserved—meaning the edges stay nice and crisp. For example, look at the windows in the box blurred image versus the median filtered image.
Unfortunately, finding the median can be slower than finding the mean. You could sort the values and choose the middle one but that would take at least quasilinear time. There is a technique to find the median in linear time but it can be quite awkward inside a shader. The numerical approach below approximates the median in linear time. How well it approximates the median can be controlled.
At lower quality approximations, you end up with a nice painterly look.
// ...
#define MAX_SIZE 4
#define MAX_KERNEL_SIZE ((MAX_SIZE * 2 + 1) * (MAX_SIZE * 2 + 1))
#define MAX_BINS_SIZE 100
// ...
These are the hard limits for the size
parameter, window size, and bins
array.
// ...
vec2 texSize = textureSize(colorTexture, 0).xy;
vec2 texCoord = gl_FragCoord.xy / texSize;
int size = int(parameters.x);
if (size <= 0) { fragColor = texture(colorTexture, texCoord); return; }
if (size > MAX_SIZE) { size = MAX_SIZE; }
int kernelSize = int(pow(size * 2 + 1, 2));
// ...
The size
parameter controls how blurry or smeared the effect is. If the size is at or below zero, return the current fragment untouched. From the size
parameter, calculate the total size of the kernel or window. This is how many samples you'll be taking per fragment.
Set up the binsSize
, making sure to limit it by the MAX_BINS_SIZE
.
i
and j
are used to sample the given texture around the current fragment. i
is also used as a general for loop count. count
is used in the initialization of the colors
array which you'll see later. binIndex
is used to approximate the median color.
// ...
vec4 colors[MAX_KERNEL_SIZE];
float bins[MAX_BINS_SIZE];
int binIndexes[colors.length()];
// ...
The colors
array holds the sampled colors taken from the input texture. bins
is used to approximate the median of the sampled colors. Each bin holds a count of how many colors fall into its range when converting each color into a greyscale value (between zero and one). As binsSize
approaches 100, the algorithm finds the true median almost always. binIndexes
stores the bins
index or which bin each sample falls into.
total
keeps track of how many colors you've come across as you loop through bins
. When total
reaches limit
, you return whatever bins
index you're at. The limit
is the median index. For example, if the window size is 81, limit
is 41 which is directly in the middle (40 samples below and 40 samples above).
These are used to covert and hold each color sample's greyscale value. Instead of dividing red, green, and blue by one third, it uses 30% of red, 59% of green, and 11% of blue for a total of 100%.
// ...
for (i = -size; i <= size; ++i) {
for (j = -size; j <= size; ++j) {
colors[count] =
texture
( colorTexture
, ( gl_FragCoord.xy
+ vec2(i, j)
)
/ texSize
);
count += 1;
}
}
// ...
Loop through the window and collect the color samples into colors
.
Initialize the bins
array with zeros.
// ...
for (i = 0; i < kernelSize; ++i) {
value = dot(colors[i].rgb, valueRatios);
binIndex = int(floor(value * binsSize));
binIndex = clamp(binIndex, 0, binsSize - 1);
bins[binIndex] += 1;
binIndexes[i] = binIndex;
}
// ...
Loop through the colors and convert each one to a greyscale value. dot(colors[i].rgb, valueRatios)
is the weighted sum colors.r * 0.3 + colors.g * 0.59 + colors.b * 0.11
.
Each value will fall into some bin. Each bin covers some range of values. For example, if the number of bins is 10, the first bin covers everything from zero up to but not including 0.1. Increment the number of colors that fall into this bin and remember the color sample's bin index so you can look it up later.
// ...
binIndex = 0;
for (i = 0; i < binsSize; ++i) {
total += bins[i];
if (total >= limit) {
binIndex = i;
break;
}
}
// ...
Loop through the bins, tallying up the number of colors seen so far. When you reach the median index, exit the loop and remember the last bins
index reached.
// ...
fragColor = colors[0];
for (i = 0; i < kernelSize; ++i) {
if (binIndexes[i] == binIndex) {
fragColor = colors[i];
break;
}
}
// ...
Now loop through the binIndexes
and find the first color with the last bins
indexed reached. Its greyscale value is the approximated median which in many cases will be the true median value. Set this color as the fragColor and exit the loop and shader.
Like the median filter, the kuwahara filter preserves the major edges found in the image. You'll notice that it has a more block like or chunky pattern to it. In practice, the Kuwahara filter runs faster than the median filter, allowing for larger size
values without a noticeable slowdown.
Set a hard limit for the size
parameter and the number of samples taken.
These are used to sample the input texture and set up the values
array.
Like the median filter, you'll be converting the color samples into greyscale values.
Initialize the values
array. This will hold the greyscale values for the color samples.
// ...
vec4 color = vec4(0);
vec4 meanTemp = vec4(0);
vec4 mean = vec4(0);
float valueMean = 0;
float variance = 0;
float minVariance = -1;
// ...
The Kuwahara filter works by computing the variance of four subwindows and then using the mean of the subwindow with the smallest variance.
findMean
is a function defined outside of main
. Each run of findMean
will remember the mean of the given subwindow that has the lowest variance seen so far.
Make sure to reset count
and meanTemp
before computing the mean of the given subwindow.
// ...
for (i = i0; i <= i1; ++i) {
for (j = j0; j <= j1; ++j) {
color =
texture
( colorTexture
, (gl_FragCoord.xy + vec2(i, j))
/ texSize
);
meanTemp += color;
values[count] = dot(color.rgb, valueRatios);
count += 1;
}
}
// ...
Similar to the box blur, loop through the given subwindow and add up each color. At the same time, make sure to store the greyscale value for this sample in values
.
To compute the mean, divide the samples sum by the number of samples taken. Calculate the greyscale value for the mean.
// ...
for (i = 0; i < count; ++i) {
variance += pow(values[i] - valueMean, 2);
}
variance /= count;
// ...
Now calculate the variance for this given subwindow. The variance is the average squared difference between each sample's greyscale value the mean greyscale value.
// ...
if (variance < minVariance || minVariance <= -1) {
mean = meanTemp;
minVariance = variance;
}
}
// ...
If the variance is smaller than what you've seen before or this is the first variance you've seen, set the mean of this subwindow as the final mean and update the minimum variance seen so far.
// ...
void main() {
int size = int(parameters.x);
if (size <= 0) { fragColor = texture(colorTexture, texCoord); return; }
// ...
Back in main
, set the size
parameter. If the size is at or below zero, return the fragment unchanged.
// ...
// Lower Left
findMean(-size, 0, -size, 0);
// Upper Right
findMean(0, size, 0, size);
// Upper Left
findMean(-size, 0, 0, size);
// Lower Right
findMean(0, size, -size, 0);
// ...
As stated above, the Kuwahara filter works by computing the variance of four subwindows and then using the mean of the subwindow with the lowest variance as the final fragment color. Note that the four subwindows overlap each other.
After computing the variance and mean for each subwindow, set the fragment color to the mean of the subwindow with the lowest variance.
(C) 2019 David Lettier
lettier.com


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
MEAGAN HALL
08.24.17
They say Athens happens, and this summer it really did. The happenings all started when a certain popstar decided to pay an Ohio University student’s college expenses. Here’s what you missed from each month over the summer:
Back in May, Nicki Minaj decided to surprise her fans by paying their college-related fees. Devonte Portis, a sophomore at OU and @hourdrive on Twitter, tweeted at Minaj asking her for help in paying $1,800 to return to OU in the fall. Minaj said she would pay it.
VIA TWITTER
“I feel fortunate to be a part of a fanbase where the artist loves her fans. She’s helped me through a lot with her music and interaction,” Portis said in a previous Post report. “People ask all the time why I'm obsessed with her and it's reasons like this! She's such a genuine and sweet person.”
In June, the first ever Athens Pride Fest took place with all things rainbow, including a magical rainbow horse named Emma. The horse galloped through College Green, and was brought by former state Rep. Debbie Phillips, according to a previous Post report. People loved Emma.
Also in June, people fired back at an Ashland University student who bashed OU on Twitter. The responses made everyone prOUd.
As we all approach Welcome Weekend and all the activities that go with that, it’s common knowledge that Athens will surely happen again. Stay tuned!
BackLanding Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


Here is what have changed since your last visit at 12 Novenber 2018 - 12:00 PM
+32% Growth
+40% Growth
-20% Decline
Service name
Lorem for ipsum
Doloriwp sit amet
Conctetuer
Accomplished
Remaining


To create an import filter for delimited data input files:
C:\..\HEC-DSSVue\Plugins\ImportFilters.xml
.
Create a new <format> node entry below the last <format> node following the structure in the table below:
| Node | Sub-node | Description | Example value |
|---|---|---|---|
| name | An arbitrary filter name. | River Board format (".txt") | |
| fileName | extension | The file name extension of the input data files. | txt |
| firstDataLine | The line number in a data file containing the first record of data. | 6 | |
| fileFormat | type | Specify 1 for delimited data file import filters. | 1 |
| fileFormat | columnDelimiter | The character used to separate columns. | , |
| date | column | The column number containing the date values. | 1 |
| date | yearStartChar | First character position within the date column for a record's "year". | 1 |
| date | monthStartChar | First character position within the date column for a record's "month". | 5 |
| date | dayStartChar | First character position within the date column for a record's "day". | 7 |
| time | column | The column number containing the time values (this can be the same column as the date). | 1 |
| time | hourStartChar | First character position within the time column for a record's "hour". | 9 |
| time | minuteStartChar | First character position within the time column for a record's "minute". | 11 |
| value | column | The column number containing the data values. | 2 |
| qualityFlag | column | The column number containing the quality flags (optional). | 3 |
| qualityFlag | missingValueFlag | Flag indicating missing values (optional). | M |
| qualityFlag | missingValueValue | Parameter value to be reset to "missing value" (optional). | -999 |


 Executive Producer and founder of Hollyveld Films started off in the production of television promos, but soon went on to produce commercials. Following his own interest he started producing music videos in his spare time and later longer format television series. Throughout the years he has serviced clients like Sony-Ericsson, Coca Cola, M-TV, Edcon to name a few.
He has been described as man that can singlehandedly rule a small country.
Arnold Snyman – Producer
After several awards for best film at Innibos and broadcast deals Arnold decided to join the British Army to experience true human emotion. He is now known as the “Celluloid Soldier” in our circles. After years we have finally convinced him to return to sunny South Africa and all we can say is watch out for the emotional journey this man can conjure up when he’s behind a camera. His absolute passion for the outdoors and filmmaking also makes him our go-to guy when it comes to location shoots all across South Africa.
Christian Grobbelaar - Director
Watch out for the young gun… This guy’s creativity, energy and passion for high-end motion picture medium breathes fresh life into our productions. Christian recently graduated and took the title of “Best Director” at the annual Awards Evening. He is a whirl wind of fresh ideas, a genius on narrative and a perfectionist when it come to Mise en Scene.
Watch this space.
Lauren Kirsty Meikle – Choreographer
YouTube dancing star Lauren Meikle first put on her dancing shoes at the age of 3 – and hasn’t taken them off since. She completed her first Ballet exam when she was 4, and also went on to study Modern, Tap, Hip-Hop, Freestyle, Jazz and Contemporary. Lauren’s internet presence on YouTube is growing daily, with close to 1 000 000 channel views and a fan base that follows her dancing and choreography videos avidly. She has won various dance competitions nationally and internationally, and has been featured on various television inserts for her unique dance moves. An example of her work can be seen HERE
Estiaan van Rooyen – Editor
Imagine watching Tchaikovsky playing piano. You have just experienced what it is like watching this man [machine] edit. Over the years Estiaan has worked on countless television commercials, music videos and more recently longer form productions, subsequently becoming known as one of South Africa’s fastest editors. Make no mistake, his editing might be fast, but his attention to detail is as sharp and precise as a doctor performing a delicate surgery. He might look scary, but we promise he wont bite. You can watch his reel HERE
Liam O’ Brien – Composer
Sure we all take the back seat when it comes to how “cool” this guy is when performing on stage, but not many of his fans know what a genius he is when composing musical scores in his basement. We won’t try and describe it with words, listen to some of his compositions HERE and judge for yourself. Yes. We do original music scoring.


{{project.projectStatus.name}}
{{project.projectTitle}}
{{project.projectFocusArea.name }} {{project.projectThrust.name}}Key Dates
- Awarded On
- Completed
Project Financials
- DMDII Funding
- {{project.dmdiiFunding | currency}}
- Cost Share
- {{project.costShare | currency}}


We started as a small group of students willing to change software development culture of IIT Ropar. This is just our start and in our first phase, we have 60+ Active Members currently working on 4 projects.
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, CSE
IIT Ropar
3rd Year, EE
IIT Ropar
3rd Year, CSE
IIT Ropar
And many more....


About
Store
Gmail
Images
Remove
Report inappropriate predictions
Carbon neutral since 2007
Privacy
Terms
Settings
Search settings
Advanced search
Your data in Search
Search history
Search help
Send feedback
Advertising
Business
How Search works
Sam Schneider
<EMAIL_ADDRESS>Manage your Google Account
Default
Sam Schneider
<EMAIL_ADDRESS>Sam Schneider
<EMAIL_ADDRESS>Topeka HouseChurch
<EMAIL_ADDRESS>Topeka House Church
<EMAIL_ADDRESS>All Brand accounts
Add another account
Sign out of all accounts
Privacy Policy
•
Terms of Service


I'm 21 and final year student of Computer Engineering at Government Engineering College in Modasa expecting to graduate in June 2019.
As a Software Engineer, I enjoy bridging the gap between engineering and design — combining my technical knowledge with my thoughts and solve the real life problems. My goal is always to build softwares that are scalable and efficient under the hood while providing engaging, pixel-perfect user experiences.
When I'm not in front of a computer screen, I'm probably watching TV series, having a Talk-Walk with nature, learning to solve problems using dynamic algos, or crossing off another item on my bucket list.


Index
C
|
F
|
P
|
R
|
S
|
U
C
calc_slopes() (pwlf.PiecewiseLinFit method)
F
fit() (pwlf.PiecewiseLinFit method)
fit_force_points_opt() (pwlf.PiecewiseLinFit method)
fit_with_breaks() (pwlf.PiecewiseLinFit method)
fit_with_breaks_force_points() (pwlf.PiecewiseLinFit method)
fit_with_breaks_opt() (pwlf.PiecewiseLinFit method)
fitfast() (pwlf.PiecewiseLinFit method)
P
p_values() (pwlf.PiecewiseLinFit method)
PiecewiseLinFit (class in pwlf)
predict() (pwlf.PiecewiseLinFit method)
prediction_variance() (pwlf.PiecewiseLinFit method)
pwlf (module)
R
r_squared() (pwlf.PiecewiseLinFit method)
S
standard_errors() (pwlf.PiecewiseLinFit method)
U
use_custom_opt() (pwlf.PiecewiseLinFit method)
pwlf
Navigation
Installation
How it works
Examples
pwlf package contents
About
Requirements
License
Related Topics
Documentation overview
Quick search


{% extends "app/app_base.html" %} {% load bootstrap_pager %} {% load app_extras %} {% block sidebar_extra %}
This view shows currently advertised routes for the prefixes listed in resource certs received from RPKI parents.
{% bootstrap_pager request routes %} {% endblock content %}


The following parameters are available :
- Databases
- The databases to which access is allowed. This can be an SQL regexp
if desired.
- Username
- The user allowed to access the above database. This user must already
exist in the User Permissions table.
- Hosts
- The hosts that the user can access the database from. If the option
From host permissions is chosen, then MySQL should use the
Host Permissions to control access.
- Permissions
- The MySQL operations the user is allowed to perform on the database.


--- layout: archive title: Zulip Chat Archive permalink: /stream/116395-maths/topic/strictification.html ---
If α
is a type, then as @Kevin Buzzard describes near https://leanprover.zulipchat.com/#narrow/stream/116395-maths/subject/affine.20schemes.20are.20schemes/near/126963972, we can interpret α
as a groupoid whose objects are the "inhabitants of α up to defeq" and whose morphisms are propositional equalities, that is, the morphisms from a
to b
are the inhabitants of a = b
(and so a morphism from a
to b
is unique if it exists, by proof irrelevance).
Suppose now α
is a monoid
. Then associativity is a propositional equality (a * b) * c = a * (b * c)
and not necessarily a defeq, so under this interpretation α
corresponds to a monoidal groupoid which is not necessarily strict.
But we can replace α
with a strict monoidal groupoid using standard strictification results. Here, for example, α
acts on itself by left multiplication, and then α
is isomorphic to the image of this action in the endomorphism monoid α → α
, which is strictly associative and unital.
For the monoid list t
, this is basically the "difference list" construction
More generally, any category
is isomorphic to a category
whose composition is strictly associative and unital.
I wonder how useful this observation is. I encountered it in a situation similar to the following. Consider a type indexed on a monoid, like def vector (α : Type u) (n : ℕ) := { l : list α // l.length = n }
. Then append
is an operation {n m : nat} : vector α n → vector α m → vector α (n + m)
. In order to state associativity of append
, we need to use transport across the equality (n + m) + k = n + (m + k)
, or use heterogeneous equality.
If we replaced ℕ
with a "strictly associative" version, we wouldn't need to do this.
I haven't yet tried putting this plan into practice, though.
Actually, this is kind of funny. This construction gives you a monoid which is strictly associative, but not strictly unital.
https://gist.github.com/rwbarton/658ccdd57986b32fd8be0c155c63d47e#file-strictification-lean-L21
Now as soon as I write this I realize I actually need the additive version, hah.
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


PanicBlaster
Progress
Energy
Level 0
Time 0
You Lose - DOUG DURHAM!!!
Press enter to try again
You have completed level 0
Press enter to continue
Your browser doesn't support the HTML 5 canvas element that this game requires.
Please try IE9, Chrome, Safari or Firefox.
Don't Panic
Press enter to continue
Move: Arrow Keys
Fire: Spacebar
Boost: Ctrl
Game Paused
Press 'p' to Continue


Learn More About Me!
Farhan Hai Khan is a Data Science Geek currently pursuing Electrical Engineering at Institute of Engineering & Management, Kolkata, with experience working with competitive teams and famous firms. His research background in Artificial Intelligence, Machine Learning, Computer Vision & Deep Learning inform his technical and scientific approaches. Farhan is fuelled by his passion for understanding the nuances of Neural Networks & Data Analytics. He considers himself a ‘forever student’, eager to both build on his academic foundations in AI & ML and stay in tune with the latest technological advancements through continued coursework.
He is currently a part of the Artificial Intelligence Technical Team at Developer Student’s Club IEM & is a Core Working Committee Member at Institute of Engineering & Technology IEM and working as a Machine Learning Intern at IIT Kharagpur. He is currently guiding students under Winter of Code as a mentor for DSCIEM.
His hunger for knowledge and determination to turn information into action has contributed to her most recent success at various groups, where he led his teams to award-winning campaigns for respectable firms. Meanwhile, he vastly improved the productivity of his team by implementing strategic project management methods and ensuring a work-life balance for his department. Farhan strongly believes mindfulness in the workplace is key to success - a tenet he lives out through his interests in chess, football, music and coding. Farhan has worked as a Data Science Intern at BrickView Studios and is always interested in competitive challenges over his Independent Research often expressing his technical knowledge over famous blogging sites such as Medium. Know more about him at: khanfarhan10.github.io or contact him at<EMAIL_ADDRESS>Check Out My Resume
Accomplished Data Science Practitioner with experience in Machine Learning, Deep Learning & Computer Vision. Proficient in Python/MATLAB programming, Delivering valuable data through analytical functionality and data retrieval methodologies with predictive modeling, data processing, and data mining. Deploying Artificial Intelligence applications to production using Flask. Actively Researching in Artificial Intelligence Technologies.
INSTITUTE OF ENGINEERING & MANAGEMENT | IEM
Cum. GPA: 8.34 / 10.0 | Kolkata, IN
ST. XAVIER'S SCHOOL | SXS
89.4 % | Physics | Chemistry | Mathematics | Computer Science |
Hazaribagh, IN
ST. XAVIER'S SCHOOL | SXS
CGPA : 9.6 / 10.0 | Hazaribagh, IN
Innovation and Entrepreneurship Development Center IEM, Kolkata, IN
Indian Institute of Technology Kharagpur (IIT KGP), Remote
Takenmind Technologies, Remote
BrickView Studios Technologies Private Limited, Kolkata, IN
Maihar Marketing Private Limited, Hazaribagh, IN
Contact Me
Kolkata, India
<EMAIL_ADDRESS>+91<PHONE_NUMBER>


I want it!
Thanks for joining us! You'll receive an email shortly — please click the link inside to confirm.


partial=False,
axis=None)
while True:
yield next(batches)
// HACK type "object". for now, we simply discard those
// HACK buggy batches.
// TODO fix the problem upstream in .samples()
if any(batch.dtype == np.object_ for batch in next_batch.values()):
msg = f"Skipping malformed batch."
warnings.warn(msg)
continue


i really like the cowboy emoji and my sleep schedule is probably permanently messed up but its all gonna be okay :)


| ??? | ?? |
|---|---|
| org.springframework.core.codec | |
| org.springframework.core.io |
Generic abstraction for (file-based) resources, used throughout the framework.
|
| org.springframework.core.io.buffer |
Generic abstraction for working with byte buffer implementations.
|
| org.springframework.core.io.support |
Support classes for Spring's resource abstraction.
|
| org.springframework.core.type.classreading |
Support classes for reading annotation and class-level metadata.
|
| ?????? | ????? |
|---|---|
protected Resource |
ResourceDecoder.decodeDataBuffer(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
| ?????? | ????? |
|---|---|
reactor.core.publisher.Flux<Resource> |
ResourceDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
| ?????? | ????? |
|---|---|
protected reactor.core.publisher.Flux<DataBuffer> |
ResourceEncoder.encode(Resource resource,
DataBufferFactory dataBufferFactory,
ResolvableType type,
MimeType mimeType,
Map<String,Object> hints) |
| ?????? | ????? |
|---|---|
interface |
ContextResource
Extended interface for a resource that is loaded from an enclosing
'context', e.g. from a
ServletContext but also
from plain classpath paths or relative file system paths (specified
without an explicit prefix, hence applying relative to the local
ResourceLoader 's context). |
interface |
WritableResource
Extended interface for a resource that supports writing to it.
|
| ?????? | ???? |
|---|---|
class |
AbstractFileResolvingResource
Abstract base class for resources which resolve URLs into File references,
such as
UrlResource or ClassPathResource . |
class |
AbstractResource
Convenience base class for
Resource implementations,
pre-implementing typical behavior. |
class |
ByteArrayResource
Resource implementation for a given byte array. |
class |
ClassPathResource
Resource implementation for class path resources. |
protected static class |
DefaultResourceLoader.ClassPathContextResource
ClassPathResource that explicitly expresses a context-relative path
through implementing the ContextResource interface.
|
class |
DescriptiveResource
Simple
Resource implementation that holds a resource description
but does not point to an actually readable resource. |
class |
FileSystemResource
Resource implementation for java.io.File handles. |
class |
FileUrlResource
Subclass of
UrlResource which assumes file resolution, to the degree
of implementing the WritableResource interface for it. |
class |
InputStreamResource
Resource implementation for a given InputStream . |
class |
PathResource
Resource implementation for java.nio.file.Path handles. |
class |
UrlResource
Resource implementation for java.net.URL locators. |
class |
VfsResource
JBoss VFS based
Resource implementation. |
| ?????? | ????? |
|---|---|
Resource |
AbstractResource.createRelative(String relativePath)
This implementation throws a FileNotFoundException, assuming
that relative resources cannot be created for this resource.
|
Resource |
ClassPathResource.createRelative(String relativePath)
This implementation creates a ClassPathResource, applying the given path
relative to the path of the underlying resource of this descriptor.
|
Resource |
DefaultResourceLoader.ClassPathContextResource.createRelative(String relativePath) |
Resource |
FileSystemResource.createRelative(String relativePath)
This implementation creates a FileSystemResource, applying the given path
relative to the path of the underlying file of this resource descriptor.
|
Resource |
FileUrlResource.createRelative(String relativePath) |
Resource |
PathResource.createRelative(String relativePath)
This implementation creates a PathResource, applying the given path
relative to the path of the underlying file of this resource descriptor.
|
Resource |
Resource.createRelative(String relativePath)
Create a resource relative to this resource.
|
Resource |
UrlResource.createRelative(String relativePath)
This implementation creates a
UrlResource , applying the given path
relative to the path of the underlying URL of this resource descriptor. |
Resource |
VfsResource.createRelative(String relativePath) |
Resource |
DefaultResourceLoader.getResource(String location) |
Resource |
ResourceLoader.getResource(String location)
Return a Resource handle for the specified resource location.
|
protected Resource |
ClassRelativeResourceLoader.getResourceByPath(String path) |
protected Resource |
DefaultResourceLoader.getResourceByPath(String path)
Return a Resource handle for the resource at the given path.
|
protected Resource |
FileSystemResourceLoader.getResourceByPath(String path)
Resolve resource paths as file system paths.
|
Resource |
ProtocolResolver.resolve(String location,
ResourceLoader resourceLoader)
Resolve the given location against the given resource loader
if this implementation's protocol matches.
|
| ?????? | ????? |
|---|---|
<T> Map<Resource,T> |
DefaultResourceLoader.getResourceCache(Class<T> valueType)
Obtain a cache for the given value type, keyed by
Resource . |
| ?????? | ????? |
|---|---|
static reactor.core.publisher.Flux<DataBuffer> |
DataBufferUtils.read(Resource resource,
DataBufferFactory dataBufferFactory,
int bufferSize)
Read the given
Resource into a Flux of DataBuffer s. |
static reactor.core.publisher.Flux<DataBuffer> |
DataBufferUtils.read(Resource resource,
long position,
DataBufferFactory dataBufferFactory,
int bufferSize)
Read the given
Resource into a Flux of DataBuffer s
starting at the given position. |
| ?????? | ????? |
|---|---|
protected Resource |
PathMatchingResourcePatternResolver.convertClassLoaderURL(URL url)
Convert the given URL as returned from the ClassLoader into a
Resource . |
protected Resource[] |
PathMatchingResourcePatternResolver.findAllClassPathResources(String location)
Find all class location resources with the given location via the ClassLoader.
|
Resource |
LocalizedResourceHelper.findLocalizedResource(String name,
String extension,
Locale locale)
Find the most specific localized resource for the given name,
extension and locale:
The file will be searched with locations in the following order,
similar to
java.util.ResourceBundle 's search order:
[name]_[language]_[country]_[variant][extension]
[name]_[language]_[country][extension]
[name]_[language][extension]
[name][extension]
If none of the specific files can be found, a resource
descriptor for the default location will be returned. |
protected Resource[] |
PathMatchingResourcePatternResolver.findPathMatchingResources(String locationPattern)
Find all resources that match the given location pattern via the
Ant-style PathMatcher.
|
Resource |
EncodedResource.getResource()
Return the
Resource held by this EncodedResource . |
Resource |
ResourceRegion.getResource()
Return the underlying
Resource for this ResourceRegion |
Resource |
PathMatchingResourcePatternResolver.getResource(String location) |
Resource[] |
PathMatchingResourcePatternResolver.getResources(String locationPattern) |
Resource[] |
ResourcePatternResolver.getResources(String locationPattern)
Resolve the given location pattern into Resource objects.
|
protected Resource |
PathMatchingResourcePatternResolver.resolveRootDirResource(Resource original)
Resolve the specified resource for path matching.
|
| ?????? | ????? |
|---|---|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindAllClassPathResources(String path)
Find all class location resources with the given path via the ClassLoader.
|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindMatchingFileSystemResources(File rootDir,
String subPattern)
Find all resources in the file system that match the given location pattern
via the Ant-style PathMatcher.
|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindPathMatchingFileResources(Resource rootDirResource,
String subPattern)
Find all resources in the file system that match the given location pattern
via the Ant-style PathMatcher.
|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindPathMatchingJarResources(Resource rootDirResource,
URL rootDirURL,
String subPattern)
Find all resources in jar files that match the given location pattern
via the Ant-style PathMatcher.
|
| ?????? | ????? |
|---|---|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindPathMatchingFileResources(Resource rootDirResource,
String subPattern)
Find all resources in the file system that match the given location pattern
via the Ant-style PathMatcher.
|
protected Set<Resource> |
PathMatchingResourcePatternResolver.doFindPathMatchingJarResources(Resource rootDirResource,
URL rootDirURL,
String subPattern)
Find all resources in jar files that match the given location pattern
via the Ant-style PathMatcher.
|
static void |
PropertiesLoaderUtils.fillProperties(Properties props,
Resource resource)
Fill the given properties from the given resource (in ISO-8859-1 encoding).
|
protected boolean |
PathMatchingResourcePatternResolver.isJarResource(Resource resource)
Return whether the given resource handle indicates a jar resource
that the
doFindPathMatchingJarResources method can handle. |
static Properties |
PropertiesLoaderUtils.loadProperties(Resource resource)
Load properties from the given resource (in ISO-8859-1 encoding).
|
protected Resource |
PathMatchingResourcePatternResolver.resolveRootDirResource(Resource original)
Resolve the specified resource for path matching.
|
void |
PropertiesLoaderSupport.setLocation(Resource location)
Set a location of a properties file to be loaded.
|
void |
PropertiesLoaderSupport.setLocations(Resource... locations)
Set locations of properties files to be loaded.
|
| ?????? | ????? |
|---|---|
protected void |
PathMatchingResourcePatternResolver.addAllClassLoaderJarRoots(ClassLoader classLoader,
Set<Resource> result)
Search all
URLClassLoader URLs for jar file references and add them to the
given set of resources in the form of pointers to the root of the jar file content. |
protected void |
PathMatchingResourcePatternResolver.addClassPathManifestEntries(Set<Resource> result)
Determine jar file references from the "java.class.path." manifest property and add them
to the given set of resources in the form of pointers to the root of the jar file content.
|
| ?????? |
|---|
EncodedResource(Resource resource)
Create a new
EncodedResource for the given Resource ,
not specifying an explicit encoding or Charset . |
EncodedResource(Resource resource,
Charset charset)
Create a new
EncodedResource for the given Resource ,
using the specified Charset . |
EncodedResource(Resource resource,
String encoding)
Create a new
EncodedResource for the given Resource ,
using the specified encoding . |
ResourcePropertySource(Resource resource)
Create a PropertySource based on Properties loaded from the given resource.
|
ResourcePropertySource(String name,
Resource resource)
Create a PropertySource having the given name based on Properties
loaded from the given encoded resource.
|
ResourceRegion(Resource resource,
long position,
long count)
Create a new
ResourceRegion from a given Resource . |
| ?????? | ????? |
|---|---|
Resource |
MetadataReader.getResource()
Return the resource reference for the class file.
|
| ?????? | ????? |
|---|---|
MetadataReader |
CachingMetadataReaderFactory.getMetadataReader(Resource resource) |
MetadataReader |
MetadataReaderFactory.getMetadataReader(Resource resource)
Obtain a MetadataReader for the given resource.
|
MetadataReader |
SimpleMetadataReaderFactory.getMetadataReader(Resource resource) |


This inspection will check if the class has a missing @author.
if there is no javadoc for the class, it will create a default one. If only the @author is missing it will add it.