import ctypes
from collections import Iterable, OrderedDict
from functools import reduce
from itertools import chain, combinations, product, zip_longest
from operator import attrgetter, mul
import numpy as np
import sympy
__all__ = ['prod', 'as_tuple', 'is_integer', 'generator', 'grouper', 'split',
'roundm', 'powerset', 'invert', 'flatten', 'single_or', 'filter_ordered',
'filter_sorted', 'numpy_to_ctypes', 'numpy_to_mpitypes', 'ctypes_to_C',
'ctypes_pointer', 'pprint', 'sweep', 'as_mapper']
[docs]def prod(iterable):
return reduce(mul, iterable, 1)
[docs]def as_tuple(item, type=None, length=None):
"""
Force item to a tuple.
Partly extracted from: https://github.com/OP2/PyOP2/.
"""
# Empty list if we get passed None
if item is None:
t = ()
elif isinstance(item, str):
t = (item,)
else:
# Convert iterable to list...
try:
t = tuple(item)
# ... or create a list of a single item
except (TypeError, NotImplementedError):
t = (item,) * (length or 1)
if length and not len(t) == length:
raise ValueError("Tuple needs to be of length %d" % length)
if type and not all(isinstance(i, type) for i in t):
raise TypeError("Items need to be of type %s" % type)
return t
[docs]def as_mapper(iterable, key=None):
"""
Rearrange an iterable into a dictionary of lists in which keys are
produced by the function ``key``.
"""
if key is None:
key = lambda i: i
mapper = {}
for i in iterable:
mapper.setdefault(key(i), []).append(i)
return mapper
[docs]def is_integer(value):
"""
A thorough instance comparison for all integer types.
"""
return isinstance(value, (int, np.integer, sympy.Integer))
[docs]def generator():
"""
Return a function ``f`` that generates integer numbers starting at 0
with stepping 1.
"""
def f():
ret = f.counter
f.counter += 1
return ret
f.counter = 0
return f
[docs]def grouper(iterable, n):
"""Split an interable into groups of size n, plus a reminder"""
args = [iter(iterable)] * n
return ([e for e in t if e is not None] for t in zip_longest(*args))
[docs]def split(iterable, f):
"""Split an iterable ``I`` into two iterables ``I1`` and ``I2`` of the
same type as ``I``. ``I1`` contains all elements ``e`` in ``I`` for
which ``f(e)`` returns True; ``I2`` is the complement of ``I1``."""
i1 = type(iterable)(i for i in iterable if f(i))
i2 = type(iterable)(i for i in iterable if not f(i))
return i1, i2
[docs]def roundm(x, y):
"""Return x rounded up to the closest multiple of y."""
return x if x % y == 0 else x + y - x % y
[docs]def powerset(iterable):
"powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
s = list(iterable)
return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
[docs]def invert(mapper):
"""Invert a dict of lists preserving the order."""
inverse = OrderedDict()
for k, v in mapper.items():
for i in v:
inverse[i] = k
return inverse
[docs]def flatten(l):
"""Flatten a hierarchy of nested lists into a plain list."""
newlist = []
for el in l:
if isinstance(el, Iterable) and not isinstance(el, (str, bytes)):
for sub in flatten(el):
newlist.append(sub)
else:
newlist.append(el)
return newlist
[docs]def single_or(l):
"""Return True iff only one item is different than ``None``, False otherwise.
Note that this is not a XOR function, according to the truth table of the XOR
boolean function with n > 2 inputs. Hence the name ``single_or``."""
# No
i = iter(l)
return any(i) and not any(i)
[docs]def filter_ordered(elements, key=None):
"""Filter elements in a list while preserving order.
:param key: Optional conversion key used during equality comparison.
"""
seen = set()
if key is None:
key = lambda x: x
return [e for e in elements if not (key(e) in seen or seen.add(key(e)))]
[docs]def filter_sorted(elements, key=None):
"""Filter elements in a list and sort them by key. The default key is
``operator.attrgetter('name')``."""
if key is None:
key = attrgetter('name')
return sorted(filter_ordered(elements, key=key), key=key)
[docs]def numpy_to_ctypes(dtype):
"""Map numpy types to ctypes types."""
return {np.int32: ctypes.c_int,
np.float32: ctypes.c_float,
np.int64: ctypes.c_int64,
np.float64: ctypes.c_double}[dtype]
[docs]def numpy_to_mpitypes(dtype):
"""Map numpy types to MPI datatypes."""
return {np.int32: 'MPI_INT',
np.float32: 'MPI_FLOAT',
np.int64: 'MPI_LONG',
np.float64: 'MPI_DOUBLE'}[dtype]
[docs]def ctypes_to_C(ctype):
"""Map ctypes types to C types."""
if issubclass(ctype, ctypes.Structure):
return 'struct %s' % ctype.__name__
elif issubclass(ctype, ctypes.Union):
return 'union %s' % ctype.__name__
elif issubclass(ctype, ctypes._Pointer):
return '%s*' % ctypes_to_C(ctype._type_)
elif ctype.__name__.startswith('c_'):
# A primitive datatype
# FIXME: Is there a better way of extracting the C typename ?
# Here, we're following the ctypes convention that each basic type has
# the format c_X_p, where X is the C typename, for instance `int` or `float`.
return ctype.__name__[2:-2]
else:
# A custom datatype (e.g., a typedef-ed pointer to struct)
return ctype.__name__
[docs]def ctypes_pointer(name):
"""Create a ctypes type representing a C pointer to a custom data type ``name``."""
return type("c_%s_p" % name, (ctypes.c_void_p,), {})
[docs]def pprint(node, verbose=True):
"""
Shortcut to pretty print Iteration/Expression trees.
"""
from devito.ir.iet import printAST
print(printAST(node, verbose))
[docs]def sweep(parameters, keys=None):
"""
Generator to create a parameter sweep from a dictionary of values
or value lists.
"""
keys = keys or parameters.keys()
sweep_values = [parameters[key] for key in keys]
# Ensure all values are iterables to make sweeping safe
sweep_values = [[v] if isinstance(v, str) or not isinstance(v, Iterable) else v
for v in sweep_values]
for vals in product(*sweep_values):
yield dict(zip(keys, vals))


A simple shell script manager.
A text-based go game written in python.
Easily mount git repositories as read-only file systems using FUSE.
This website.


Cheesecake Order Form
Quantity Topping
0
1
2
3
4
Plain
Cherry
Chocolate
Notes:
Order
Orders for
Month
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Nov
Dec
11 cherry
17 chocolate
31 plain


---
layout: post
title: 'Times Article (Op/Ed): "Our Not-So-Free Press"'
categories: []
tags: []
status: publish
type: post
published: true
meta:
_original_post_id: ''
_original_import_author: John Duprey
author:
---
"
Our Not-So-Free Press." We've been critical of the press, but it seems those that are actually doing their job are being fined, jailed, or otherwise persecuted.
From the editorial: "
Then there's Patrick Fitzgerald, the overzealous special prosecutor who is the Inspector Javert of our age. Mr. Fitzgerald hasn't made any progress in punishing the White House officials believed to have leaked the identity of the C.I.A. officer Valerie Plame to Robert Novak. But Mr. Fitzgerald seems determined to imprison two reporters who committed no crime, Judith Miller of The New York Times and Matthew Cooper of Time, because they won't blab about confidential sources."


Questions asked [15]
- Its is not always a guarantee that you will get answers to all of your questions.[answers 3]
- Tea Its is not always a guarantee that you will get answers to all of your questions.[answers 3]
- Milk Its is not always a guarantee that you will get answers to all of your questions.[answers 3]
- Its is not always a guarantee that[answers 3] Read More >>


| Total net profit | 0.18 | Gross profit | 4.51 | Gross loss | -4.33 |
| Profit factor | 1.04 | Expected payoff | 0.02 | ||
| Absolute drawdown | -2.21 | Maximal drawdown (%) | 2.12 (92.17%) | ||
| Total trades | 9 | Profit trades (% of total) | 7 (77.78%) | Loss trades (% of total) | 2 (22.22%) |
| Long positions (won %) | 6 (83.33%) | Short positions (won %) | 3 (66.67%) | ||
| Largest | profit trade | 1.19 | loss trade | -2.21 | |
| Average | profit trade | 0.64 | loss trade | -2.17 | |
| Minimum | profit trade | 0.21 | loss trade | -2.12 | |
| Maximum | take profit in pips | 1580.0 | stop loss in pips | -3410.0 | |
| Average | take profit in pips | 873.3 | stop loss in pips | -2754.4 | |
| Minimum | take profit in pips | 260.0 | stop loss in pips | -1570.0 | |
| Maximum | Reward-Risk | 0.7 | Duration in minutes | 4849 | |
| Average | Reward-Risk | 0.3 | Duration in minutes | 1444.7 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 142 | |
| Maximum | consecutive wins (profit in money) | 7.0 (4.51) | consecutive losses (loss in money) | 1.0 (-2.21) | |
| Average | consecutive wins | 7.0 | consecutive losses | 1.0 |
| Total net profit | 0.85 | Gross profit | 2.97 | Gross loss | -2.12 |
| Profit factor | 1.4 | Expected payoff | 0.14 | ||
| Absolute drawdown | 0.49 | Maximal drawdown (%) | 2.12 (71.38%) | ||
| Total trades | 6 | Profit trades (% of total) | 5 (83.33%) | Loss trades (% of total) | 1 (16.67%) |
| Largest | profit trade | 1.19 | loss trade | -2.12 | |
| Average | profit trade | 0.59 | loss trade | -2.12 | |
| Minimum | profit trade | 0.21 | loss trade | -2.12 | |
| Maximum | take profit in pips | 1580.0 | stop loss in pips | -3410.0 | |
| Average | take profit in pips | 766.7 | stop loss in pips | -2663.3 | |
| Minimum | take profit in pips | 260.0 | stop loss in pips | -1570.0 | |
| Maximum | Reward-Risk | 0.7 | Duration in minutes | 4849.0 | |
| Average | Reward-Risk | 0.3 | Duration in minutes | 1761.0 | |
| Minimum | Reward-Risk | 0.1 | Duration in minutes | 142.0 | |
| Maximum | consecutive wins (profit in money) | 5.0 (2.97) | consecutive losses (loss in money) | 1.0 (-2.12) | |
| Average | consecutive wins | 5.0 | consecutive losses | 1.0 |
| Total net profit | -0.67 | Gross profit | 1.54 | Gross loss | -2.21 |
| Profit factor | 0.7 | Expected payoff | -0.22 | ||
| Absolute drawdown | 0.0 | Maximal drawdown (%) | 0.0 (0.0%) | ||
| Total trades | 3 | Profit trades (% of total) | 2 (66.67%) | Loss trades (% of total) | 1 (33.33%) |
| Largest | profit trade | 0.85 | loss trade | -2.21 | |
| Average | profit trade | 0.77 | loss trade | -2.21 | |
| Minimum | profit trade | 0.69 | loss trade | -2.21 | |
| Maximum | take profit in pips | 1180.0 | stop loss in pips | -3010.0 | |
| Average | take profit in pips | 1086.7 | stop loss in pips | -2936.7 | |
| Minimum | take profit in pips | 930.0 | stop loss in pips | -2820.0 | |
| Maximum | Reward-Risk | 0.4 | Duration in minutes | 1350.0 | |
| Average | Reward-Risk | 0.4 | Duration in minutes | 812.0 | |
| Minimum | Reward-Risk | Duration in minutes | 523.0 | ||
| Maximum | consecutive wins (profit in money) | 2.0 (1.54) | consecutive losses (loss in money) | 1.0 (-2.21) | |
| Average | consecutive wins | 2.0 | consecutive losses | 1.0 |


{{for css_file in css_files:}}
{{pass}} {{for js_file in js_files:}} {{pass}}
Termite Visualizations
http://
/
/
{{include}}


Class
Homework
For
Done?
×
No Homeworks were found! Use CTRL+N to add new homeworks
×
Succefully removed {homework}


Select the scanner and start the scenario of scanning from Flatbed by clicking on Start Scenario button.


Minneapolis Public School leaders recently unveiled a plan to restructure the district’s schools — calling for sweeping changes they say will address race and class disparities and help close the achievement gap among student groups.
The five proposed models employ different strategies, which all aim to stem the flow of kids out of the district, reduce race and class segregation, slash transportation costs and use those savings for classroom instruction.
These strategies include cutting the number of magnet schools and locating them in the center of the city and, in some of the models, eliminating K-8 schools and using K-5 and 6-8 schools only. As a result, attendance boundary areas for community (non-magnet) schools would also shift.
But many Minneapolis families are wary of Superintendent Ed Graff’s restructuring plan, noting that his proposed changes will cause major upheaval across the city, increase segregation in schools and cause further hemorrhaging of students. Others charge that the data the district used is misleading and does not take into account many factors.
The district has been operating under the current plan for more than a decade and has since shrunk from 34,680 to 33,380 students. It also faces a $19 million budget shortfall for the next school year thanks in large part to continued declining enrollment. There’s an increased urgency among district leaders to mitigate this problem and rescue a school system once flush with students from further erosion.
The district currently has about 14 magnet schools and spends about $4.6 million transporting students to those schools, which are mostly situated in the southern part of the city. District data shows that the current structure has led to more segregated schools and a growing student achievement gap. Meanwhile, schools in north and northeast Minneapolis have not benefited from the district’s current choice policy, making those schools less attractive to its residents. Models two and four, which are almost the same, focus on dual-language programs. These models recommend having centralized bilingual programs in three community schools — that are yet to be identified — in parts of the city with the largest Spanish-speaking populations. The difference between them is whether they are going to limit K-8 schools or not.
Meanwhile, models three and five have an immersion focus. These models would eliminate Windom’s language immersion program, but would add a third K-5 Spanish immersion magnet at Green Central. The main difference between these models is whether or not they would have K-8 schools.
Dowling, Windom and other magnets — Clara Barton Open School, Armatage Montessori and Anwatin Spanish Dual Immersion — would be recast as traditional community schools. The proposed models do not offer an environmental magnet focus, which means Dowling would also lose its environmental status. District leaders said schools that lose their magnet status could still apply for specialty school designation but the programs they want shouldn’t compete with offerings at magnet schools, noting that it would conflict with their goal of integrating magnet schools.
The plan would relocate magnet schools to the center of the city and attendance boundaries for community schools could be redrawn, reassigning nearly two-thirds of students to new schools. Meanwhile, elementary and middle school grade levels could also be reconfigured under most of the models and underenrolled schools deemed academically ineffective could be shuttered.
Moving students back into their community schools would save the district between $3 million to $5 million, money Minneapolis school leaders are eyeing for classroom instruction to help close gaps in student achievement. But a school community survey currently being conducted by the district could influence where those dollars should be prioritized. District leaders said they are not taking away choice. But families that choose a non-magnet school would be forced to provide their own transportation.
Minneapolis Public Schools is highly segregated by race and income. Currently, there are about 20 “racially-isolated” schools in the district and most of them are located in north Minneapolis. Meaning these schools have more than 80% students who belong to one student group. District leaders said moving magnets into the center of the city would help reduce the segregation by more than half and provide socioeconomic diversity.
Their average target for school integration is 65% students of color and 35% white students. Under the redesign, the magnet schools are expected to have no more than 70% students of color and low-income students. But the lack of affordable housing in the city, the fact that fewer white families are enrolling their children in the district, and more middle-income families of color are open-enrolling elsewhere could make it difficult for community schools to achieve their socioeconomic and racial integration goal, Moore said.
About 90% of the district’s black students qualify for free or reduced-price school lunch. District leaders note reducing the number of racially identifiable schools would also decrease the number of high poverty schools.
“This reduction, along with our teacher equity plan, focus on K-2 literacy, and equity, restorative practices training will improve these schools significantly,” said Eric Moore, the district’s chief of accountability, innovation and research.
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
In September 2019, Graff announced a new timeline for his restructuring plan. Graff and his team are expected to recommend one of the models to the school board on March 24. At this meeting the district will present details about costs of reconfiguring schools and other information, including how to enroll in the magnets. In the meantime, district leaders are gathering feedback. The school board could make suggestions before it votes on the final plan in April. After the vote, structural changes would not happen until the 2021-22 school year, with some of the bigger changes taking longer to implement.


Ready to play?
First here are the rules:
This Ping-Pong game will count your number starting from 1, except this numbers:
- Numbers divisible by 3 are replaced with "ping"
- Numbers divisible by 5 are replaced with "pong"
- Numbers divisible by 15 are replaced with "ping-pong"


We should know the dimensions of both images, and they should be hidden in the root of the body until loaded.


Score: {{ score }}
{{ question['q'] }}
Show Solution {{ solution }}
While typing your answer, you can always press 1 to reveal the answer. You also do not have to think about capitalization when making your guess.
Available Question Sets
{{ item }}
Theme


All army regiments needed musicians. Fifes and drums were used to regulate the daily activities of the troops.
They signaled when the troops should rise in the morning and retire at night, when to eat, when to assemble,
and to sound an alarm. Musicans were also required to perform most of the duties assigned to all soliders.


Describes my REST API
GET method
* Request URL : GET /api/list
* Response Data :
[
{
"id": 1,
"english": "autonomy",
"japanese": "自主・自律・自立",
"sentence": "A good boss will provide her workers with the autonomy necessary to create their own ideal working conditions.",
"memo": "the capacity of an agent to act in accordance with objective morality rather than under the influence of desires.",
"createdAt": "05:06:04"
},
{
"id": 2,
"english": "consistent",
"japanese": "一貫した",
"sentence": "She’s the team’s most consistent player.",
"memo": "always behaving in the same way or having the same attitudes, standards etc",
"createdAt": "05:06:04"
}
]
POST method
* Request URL : POST /api/list
* Body Json Data :
{
"english": "ensure",
"japanese": "確保する",
"sentence": "He took daily vitamins to ensure that he would remain healthy",
"memo": "to make certain that something will happen properly"
}
{
"id": 4,
"english": "ensure",
"japanese": "確保する",
"sentence": "He took daily vitamins to ensure that he would remain healthy",
"memo": "to make certain that something will happen properly",
"createdAt": "06:36:38"
}
DELETE method
* Request URL : DELETE /api/list
* Body Json Data :
PATCH method
* Request URL : PATCH /api/list
* Body Json Data :
{
"english": "ensure",
"japanese": "確保する, 保証する",
"sentence": "He took daily vitamins to ensure that he would remain healthy",
"memo": "to make certain that something will happen properly"
}
No body returned for response


Put simply, testing is the process of confirming that something is working as intended. It is typical in any creation process, for example a chef may taste his or her soup to decide whether it tastes as they hoped or whether it needs more seasoning. Software development in particular benefits from testing, because unlike cooking it rarely follows a very rigid process and the end result can take many different forms.
The main reason is simply to find bugs. However, automated tests in particular bring more advantages:
The most common form of testing is one that everyone will have done in some context during their life and that is manual testing. For us that would likely involve running through our applications flow and checking it all works properly, manually clicking through as the user would.
This is good for smaller projects as creating automated tests is a lot of potential overhead for little gain when it can be easily covered manually. In other words, it would be overkill. However, manual testing doesn't scale very well and as the application grows manual testing can be extremely time-consuming. It also becomes more and more likely that human error can occur during testing, especially because it can become quite tedious and minds can wander.
Unit testing is the most granular form of testing and is very narrow in scope. A unit test tests one specific piece of functionality, often a literal function. This functionality will be isolated from the rest of the code and ensure that it performs its singular job and is unconcerned with the how it fits into the rest of the code. Unit testing is the base level of testing that everything else is built upon.
Once you have a good amount of unit test coverage and can be confident that the your base units of functionality are working, you can make sure they play nicely together. We combine our simple functionalities together to create a more complex and probably more useful feature then test that feature. For example, if you have made a calculator program, you could have unit tests to ensure the different math functions like add and subtract are working, then integration tests could ensure that sums that combine these different functions still result in a correct answer. At this stage, we are often testing a single feature of our application isolated from the rest of the codebase.
Some different ways to perform integration testing are:
The next step up from integration testing is system testing. Previously, with unit and integration testing we have been isolating the code we're testing from the rest of our codebase, but system testing now concerns our whole application. It is a black box testing method, because it isn't concerned about how the application does its job, it only cares whether the job is done.
Now we're sure the application is doing something correctly, we need to also make sure the application fulfills the initial requirements or if the focus of the application has drifted away during development. After all, we wouldn't want coffee machine software that only makes a cup of tea, no matter how reliably it makes that tea (or if the tea is any good).
If we have performed at the very least the first few testing stages, we will now be confident that we have working software of some sort. We can now test whether are aplication can continue to perform its functions well under the pressure of heavy traffic. This can take a few different forms as outlined below.
Security testing involves looking for security vunerabilities in your software. Some common vunerabilities could be SQL injections, famously allowing malicious users to enter SQL commands into an unsanitised input with disasterous results such as user tables being dropped. Similarly, Javascript injections can also happen in the same way causing the application to run unintended code, which in turn could give attacks useful information. Code injections aren't limited to these two languages.
Usability tests ensure that the differnets paths through the website are as intuitive as possible for the end user.
Compatibility tests ensure that the application works consistantly in all environments it uses, whether that be different browsers or different operating systems.
White box testing is testing that is concerned with the internals of the codebase. Black box testing is the opposite where it is only concerned with testing the functionality, which could also be considered as testing from the end user's perspective. You could summarise the difference as white box testng being about the how and black box testing being about the what.


Class FileLogger
This implements a logger which writes to a log file in the background Filename and directory are configurable, also rolling filename and compression can be activated
Inherited Members
Namespace:Dapplo.Log.LogFile
Assembly:Dapplo.Log.LogFile.dll
Syntax
public class FileLogger : AbstractLogger, ILogger, IDisposable, IFileLoggerConfiguration, ILoggerConfiguration
Constructors
| Improve this Doc View SourceFileLogger()
default Constructor which starts the background task
Declaration
public FileLogger()
Properties
| Improve this Doc View SourceArchiveCompress
Compress the archive
Declaration
public bool ArchiveCompress { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Implements
| Improve this Doc View SourceArchiveCount
The amount of archived files which are allowed. The oldest is removed.
Declaration
public int ArchiveCount { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
Implements
| Improve this Doc View SourceArchiveDirectoryPath
The path of the archived file
Declaration
public string ArchiveDirectoryPath { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceArchiveExtension
The extension of archived file, default this is ".log.gz"
Declaration
public string ArchiveExtension { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceArchiveFilenamePattern
Change the format for the archived filename
Declaration
public string ArchiveFilenamePattern { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceArchiveHistory
The history of archived files, this could e.g. be stored in a configuration
Declaration
public IList<string> ArchiveHistory { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.IList<System.String> |
Implements
| Improve this Doc View SourceDirectoryPath
Change the format for the filename, the possible arguments are documented in the . Environment variablen are also expanded.
Declaration
public string DirectoryPath { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceExtension
The extension of log file, default this is ".log"
Declaration
public string Extension { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceFilenamePattern
Change the format for the filename, as soon as the filename changes, the previous is archived.
Declaration
public string FilenamePattern { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceMaxBufferSize
Limit the internal stringbuilder size,
Declaration
public int MaxBufferSize { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
Implements
| Improve this Doc View SourcePreformat
Setting this to true will format the message in the context of the write call. If this is set to false, the default, the formatting is done when writing to the file. First makes the call slower, last could introduce problems with UI owned objects.
Declaration
public bool Preformat { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
Implements
| Improve this Doc View SourceProcessname
Name of the application, if null it will be created
Declaration
public string Processname { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Implements
| Improve this Doc View SourceWriteInterval
Specify how long the background task can wait until it starts writing log entries
Declaration
public int WriteInterval { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Int32 |
Implements
Methods
| Improve this Doc View SourceConfigure(ILoggerConfiguration)
Configure this logger
Declaration
public override void Configure(ILoggerConfiguration configuration)
Parameters
| Type | Name | Description |
|---|---|---|
| ILoggerConfiguration | configuration |
Overrides
| Improve this Doc View SourceWrite(LogInfo, String, Object[])
Enqueue the current information so it can be written to the file, formatting is done later.. (improves performance for the UI) Preferably do NOT pass huge objects which need to be garbage collected
Declaration
public override void Write(LogInfo logInfo, string messageTemplate, params object[] logParameters)
Parameters
| Type | Name | Description |
|---|---|---|
| LogInfo | logInfo | LogInfo |
| System.String | messageTemplate | string |
| System.Object[] | logParameters | params |
Overrides
Explicit Interface Implementations
| Improve this Doc View SourceIDisposable.Dispose()
Declaration
void IDisposable.Dispose()


| Command | Descriptor | Example Usage |
|---|---|---|
| c!8ball | Use the magic 8ball |
c!8ball am i cool?
|
| c!pop | Pop some bubble wrap |
c!pop
|
| c!cat | Random cat image |
c!cat
|
| c!dog | Random dog image |
c!dog
|
| c!numberfact | Get a fact about the given number |
c!numberfact 42
|
| c!pizza | Random pizza image |
c!pizza
|
| c!roll | Roll a die (with optional side count) |
c!roll 12
|
| c!rps | Rock, paper scissors. |
c!rps rock
|


public class FloorGrid
extends java.lang.Object
| Constructor and Description |
|---|
FloorGrid()
constructor Fills the entire matrix with grass floors
|
FloorGrid(int[][] newMapMatrix)
constructor Fills the mapMatrix with the newMapMatrix parameter by reading
each number and corresponding it to the type of floor it represents also
creates a floor object that represents it and fills the mapMatrix with it
|
| Modifier and Type | Method and Description |
|---|---|
void |
drawGridOnScreen()
Draws the grid matrix on the screen by looping throug the mapMatrix and
temporary mapping each floor to a temp floor object
|
void |
drawGridOnScreenMapPreview(int floorSize,
int xOffset,
int yOffset)
Draws the mapMatrix on the screen with the specified floor size
|
Floor |
getFloor(int xCoord,
int yCoord)
Retrurns the floor object represented by the xCoord and the yCoord pre: none
post: A floor object is returned represented by the x and y coords
|
int |
getSquaresHigh() |
int |
getSquaresWide()
Generated Getters and Setters
|
void |
setFloor(int xCoord,
int yCoord,
FloorType type)
Sets the floor where specified pre: none post: sets the floor where specified
by the x and y coord and the floortype
|
void |
setSquaresHigh(int squaresHigh) |
void |
setSquaresWide(int squaresWide) |
public Floor[][] mapMatrix
public FloorGrid(int[][] newMapMatrix)
public FloorGrid()
public void setFloor(int xCoord, int yCoord, FloorType type)
public Floor getFloor(int xCoord, int yCoord)
public void drawGridOnScreen()
public void drawGridOnScreenMapPreview(int floorSize, int xOffset, int yOffset)
public int getSquaresWide()
public void setSquaresWide(int squaresWide)
public int getSquaresHigh()
public void setSquaresHigh(int squaresHigh)


About Me
Showcase is a modern, beautiful personal website template to showcase who you are, as well as projects you've worked on in the past.
Showcase was built from the ground up with Bulma to be fast and responsive out of the box with all source files well documented for easy to customization. The Showcase template gives you a personal space to share what you are all about as a creative designer, developer, photographer, and more!
Give me a ring
123-456-7890
Email Me
<EMAIL_ADDRESS>View my portfolio
example.com