My Team
Sally
Manager
ID: 90
Email:
<EMAIL_ADDRESS>Office number: 7
Joe
Engineer
ID: 67
Email:
<EMAIL_ADDRESS>GitHub:
joe78
Bob
Intern
ID: 34
Email:
<EMAIL_ADDRESS>School: UCLA


Bowie the Wonder Horse
| Job Description | |
| Position Title | Entertainer |
| Location | Hollywood, CA |
| Employment Type | Full Time |
| Experience | Mid-level |
| Status | Open |
| Description | The open position of Animal Star is responsible for interacting with and providing a pure source of fun and entertainment to all humans and animals. Duties include birthday parties, movie cameos, commercial spots, and being present across all major social media platforms (Facebook, Instagram, Twitter). Responsible for keeping up-to-date information on other acts, and required to attend all meetings held by Giuseppe Pig. Having a valid portfolio and a large Instagram following is preferred. |
| Hiring Lead | Giuseppe Pig |
| Starting Salary | $200k, 60% per gig, Unlimited food and housing |


More info
zoomer package
just as it says
More info


(Paris, April 15, 1990) I am an actress, model, British philanthropist and animal lover. I love cats.


Mandy's Portfolio
Student work from M.Sc. in New Media
Creative Technologies Design -
Medical Mobile Application
Click Here to View
Data Driven Products - Thematic Website Development
Click Here to View
Multimedia Design -
Interactive Company Portfolio
Click Here to View
Data Science Project -
Thematic Data Analytics
Click Here to View
Improve Search Engine Optimization (SEO) - Tactics
Click Here to View
Content Development -
Television Advertisement Storyboard
Click Here to View
Other Experience
Social media: Instagram account daily operation and management
belivehk
IG shop
>1,100 followers
feedugirls
Foodie account
>900 followers
©NMY. All rights reserved.


public class TrafficsenseContainer
extends java.lang.Object
getInstance()
. All entities such as Activity and Service
interacting with the singleton must invoke activityAttach(Context)
or
serviceAttach(Context)
before other operations. The entity must
invoke activityDetach()
or serviceDetach()
after it finishes
its work with the singleton.| Modifier and Type | Field and Description |
|---|---|
(package private) static java.lang.String |
CTXLOG_PIPELINE_NAME
ContextLogger / Funf pipline name
|
private static TrafficsenseContainer |
instance
The shared instance of this singleton.
|
private static java.lang.Object |
instanceLock
An object which serves as a lock to synchronize
getInstance() . |
private boolean |
isLoading |
private int |
mAttachedActivities
Number of attached Activity.
|
private Context |
mContext
The associated context.
|
private edu.mit.media.funf.FunfManager |
mCtxLogFunfManager
The underlying FunfManager (which is a Service) of ContextLogger.
|
private ServiceConnection |
mCtxLogFunfManagerConn
Connection to the ContextLogger.
|
private com.google.gson.JsonObject |
mJourneyJsonObject
Last parsed journey as Gson JsonObject.
|
private java.lang.String |
mJourneyText
Last set/retrieved plain text journey.
|
private PebbleCommunication |
mPebbleCommunication
Communication handler of Pebble.
|
private PebbleUiController |
mPebbleUi
Pebble UI Controller.
|
private Route |
mRoute
Current journey in internal data structure.
|
private int |
mRunningServices
Number of attached Service.
|
| Modifier | Constructor and Description |
|---|---|
private |
TrafficsenseContainer()
Singleton class, invoke
getInstance() instead. |
| Modifier and Type | Method and Description |
|---|---|
void |
activityAttach(Context ctx)
Attach an Activity to the singleton.
|
void |
activityDetach()
Detach an Activity from the singleton.
|
private void |
close()
Release resources.
|
static TrafficsenseContainer |
getInstance()
Returns the shared instance of this singleton object.
|
com.google.gson.JsonObject |
getJourneyObject()
Return current journey as a Gson JsonObject.
|
java.lang.String |
getJourneyText()
Return current plain text journey.
|
PebbleUiController |
getPebbleUiController()
Return current Pebble UI Controller object.
|
Route |
getRoute()
Return current Route object.
|
boolean |
isJourneyStarted()
Whether at least one journey tracker service is active.
|
private boolean |
isLast()
Check if we are the last to detach from the singleton.
|
boolean |
isLoading()
returns a boolean value indicating whether info (email, coords) is being loaded.
|
private void |
open(Context ctx)
Initialized the singleton.
|
void |
parseJourney()
Parse plain text journey and set up internal Route object.
|
static void |
retrieveCoordinatesForStopsBlockingPart(Route route)
Retrieves GPS coordinates for all stops along the journey.
|
void |
retrieveJourney(EmailCredential credential,
View update,
java.lang.Runnable after)
Retrieves a journey in plain text from the given e-mail account.
|
static java.lang.String |
retrieveJourneyBlockingPart(EmailCredential credential)
Retrieve the journey text from the last message in the inbox of the given account.
|
boolean |
serviceAttach(Context ctx)
Attach a Service and a Context to the singleton.
|
void |
serviceDetach()
Detach the Service from the singleton.
|
void |
setJourneyText(java.lang.String journey)
Assign a string as the plain text journey.
|
void |
setPebbleUiController(PebbleUiController pebbleUi)
Assign a Pebble UI Controller object for use.
|
void |
setRoute(Route route)
Assign a Route object for use.
|
private boolean |
shouldInit()
Check if the shared instance should be initialized.
|
void |
startJourneyTracker(int serviceType,
EmailCredential credential)
Retrieve and start following a journey in a separate Thread.
|
void |
startTrackerService(int serviceType)
Launch the journey tracker service selected.
|
void |
stopJourney()
Stop following current journey.
|
static final java.lang.String CTXLOG_PIPELINE_NAME
private static volatile TrafficsenseContainer instance
private Context mContext
private ServiceConnection mCtxLogFunfManagerConn
private edu.mit.media.funf.FunfManager mCtxLogFunfManager
private PebbleCommunication mPebbleCommunication
private PebbleUiController mPebbleUi
private volatile Route mRoute
startTrackerService(int)
private volatile java.lang.String mJourneyText
private volatile com.google.gson.JsonObject mJourneyJsonObject
private volatile int mAttachedActivities
activityAttach(Context)
,
activityDetach()
private volatile int mRunningServices
serviceAttach(Context)
,
serviceDetach()
private volatile boolean isLoading
private static volatile java.lang.Object instanceLock
getInstance()
.private TrafficsenseContainer()
getInstance()
instead.public static TrafficsenseContainer getInstance()
private boolean shouldInit()
open(Context)
if this is the case.private boolean isLast()
close()
if this is the case.public boolean isLoading()
public void activityAttach(Context ctx)
ctx
- the Context to be associated.public void activityDetach()
public boolean serviceAttach(Context ctx)
ctx
- (currently unused).public void serviceDetach()
public boolean isJourneyStarted()
public void stopJourney()
private void open(Context ctx)
close()
afterwards to release resources.ctx
- the Context for all further operations.close()
private void close()
open(Context)
public void startJourneyTracker(int serviceType, EmailCredential credential)
serviceType
- type of journey tracker service desired.credential
- account details for accessing mailbox.for supported serviceTypes.
public void startTrackerService(int serviceType)
parseJourney()
or setRoute(Route)
.
Types currently supported are: SERVICE_TIME_ONLY and SERVICE_LOCATION_ONLY.
Pebble UI is initialized here.serviceType
- type of journey tracker service to launch.Constants
public static java.lang.String retrieveJourneyBlockingPart(EmailCredential credential) throws EmailReader.EmailException
credential
- the e-mail account to be accessed.EmailReader.EmailException
public void retrieveJourney(EmailCredential credential, View update, java.lang.Runnable after)
mJourneyText
.
May optionally update an UI element after completion.
Currently it is the last mail in inbox.credential
- e-mail account to be accessed.update
- UI element to be updated. (optional)after
- Runnable task to be posted to update. (optional)retrieveJourneyBlockingPart(EmailCredential)
public static void retrieveCoordinatesForStopsBlockingPart(Route route)
public java.lang.String getJourneyText()
public void setJourneyText(java.lang.String journey)
journey
- the journey in plain text with line breaks.mJourneyText
public void parseJourney() throws java.text.ParseException
java.text.ParseException
- from JourneyParser.parseString(String).public com.google.gson.JsonObject getJourneyObject()
parseJourney()
before this.
May return null if there is none.public void setPebbleUiController(PebbleUiController pebbleUi)
pebbleUi
- controller object to be used.public void setRoute(Route route)
route
- object to be used.public PebbleUiController getPebbleUiController()
startTrackerService(int)
,
setPebbleUiController(PebbleUiController)
public Route getRoute()
setRoute(Route)


Android Model-View-Presenter (MVP) Design Pattern
Posted on July 13, 2017 in Development
Android Model-View-Presenter (MVP) Design Pattern
Quick Introduction
There's enough material available on internet about what a
Model-View-Presenter (MVP) design pattern is, and why it should be used.
The motivation behind utilizing this design pattern is to separate UI related code from business
logic. Presenter is a facilitator between View (UI related code) and Model (real data objects).
For example, if a TextView widget wants to display a Person
's name (data object model), then View will
send a request to Presenter to fetch Data object's information. Presenter in turn will fetch Model class (Person
data model)
information and pass it on back to View. That way View would never have to directly interact with Model classes.
So, what's the benefit of this separation ? Any guesses ? Yes, you got it ... Clean code !
Such clean code separates UI related code base from model classes, and makes it super simple to unit tests without
running instrumentation tests.
Alright, I'll be using a simple example to demonstrate the real working of MVP pattern. In this example, user can pick an image from Gallery, and display it in the main UI (fragment). Along with displaying picture in ImageView widget, it also shows FilePath below the ImageView.
Selecting picture from Gallery
This sample app does following 4 things using MVP pattern:
- Allows user to pick a picture from Gallery and shows in an ImageView
- Displays File's path in TextView under ImageView
- Give user option to copy chosen image into app's data directory
- Give user option to rename picture (copied into app's data directory)
Show me code
There're two Interfaces dedicated to View and Presenter related contracts: * ContractView Interface.
public interface ContractView {
//displays image in Imageview widget
void showImagePreview(@NonNull Uri uri);
//Displays image file information in textview
void showImageInfo(String infoSting);
//That's how a presenter is assigned to a view
void setUserActionListener(ContractUserActionListener userActionListener);
}
- ContractUserActionListener Interface
public interface ContractUserActionListener {
//An action taken by user to load a image from gallery into ImageView widget
void loadImage(Context context, Uri uri) throws IOException;
//User initiates action to display image file information in textView UI
void loadImageInfo();
//User action to copy an image from gallery in to app's picture directory (app's data directory)
void copyImageIntoAppDir(Context context) throws IOException;
//User can rename a image file (in app's data directory)
void renameImage(Context context, String newName);
}
Activity or Fragment class implements ContractView
while Presenter would implements
ContractUserActionListener
.
In this sample, UI class ImageViewerFragment
is implementing ContractView
.
public class ImageViewerFragment extends Fragment implements ContractView {
...
}
And, Presenter class ImagePresenter
implements ContractUserActionListener
:
public class ImagePresenter implements ContractUserActionListener {
...
}
ImageViewerFragment
holds a reference to ImagePresenter
, so that it can pass
requests to query data from models. At the same time, ImagePresenter
holds a reference
back to ImageViewerFragment
to pass back on the results.
That concludes the theory part.
Here are few screenshots from the sample app:
Start state: This is how sample app looks just after start up. The FAB '+' is clicked to select image from gallery.
Picture loaded from Gallery state:
Image copied to App's data dir state:
Renaming image - Enter new name:
Renaming image - Final:
Source Code
Source is available at Github
Happy Exploring !


Java Software
Release Notes
The OPeNDAP software started life as the Distributed Oceanographic Data System
(DODS) project. Here are the release notes from previous version of the Java-DODS
software on which OPeNDAP is based:
Java-DODS Release 1.1.3 -- 05/12/03 (ndp)
This is a supplemental release of 1.1 that contains the fixes mentioned below
plus a fix of a regexp problem in the DRDS (bug 608).
Java-DODS Release 1.1.2 -- 03/11/03
(ndp)
This is a supplemental release of 1.1 that contains bug fixes for server side
issues that only exhibit on the Windows operating system.
Java-DODS Release 1.1.1 -- 4/9/02 (ndp)
This is a supplemental
release of 1.1 that contains bug fixes for DDS, and DAS parser problems and
repairs
to the DRDS constraint expression handling.
Java-DODS Release 1.1.0 -- 06/11/01 (ndp)
Repaired DODS relational Database Server (DRDS, dods.servers.sql.drds) so that
it correctly handles "null" values in the backend database
tables. Repaired DODS Test Server (DTS, dods.servers.test.dts). Test server output
is now stable.
Java-DODS Release 1.0.0 -- 10/13/00 (ndp)
Placed the majority of the server diagnostic output under conditional control.
Found and fixed several bugs in the server code including:
- Problem with the
string types where if a user requests variable x from a server and constrains
it on y and y is a string the server was returning y too. (example:
http://DODS.URL/dataset.dods?x&y="bob")
- Constraint Expressions
were simply not working.*
- The right operand in the Clause's of the constraint
expression was not being
correctly marked by the ExprParser (thanks to James G. for the fix.)
This should help things a bit.
Release 1.0.6 (ndp)
Many things have been changed and re-arranged:
The servlets should now be thread safe. Much of the core
servlet code has been re-architected and should be carefully
reviewed if you have been using it and wish to continue to
use it.
The servlet NO LONGER USES .ini files. All configuration information
is no passed to the servlet through the javax.servlet.ServletConfig
interface (in particular the getInitParameter() method). This information
is stored in the web.xml file located in the WEB-INF directory for
the servlet. See the file SERVLET for more information.
The special clients www and ascii have been moved from
dods.clients to dods.servers (dods.servers.www and dods.servers.ascii
respectively)
Release 1.0 (ndp)
This is the first full release of the Java-DODS core software.
Some fairly significant organizational changes have been made
since Jake's original code, and since Beta 1.1. If you have been
using the code it would behoove you to review the inheritance
hierarchy, the functional hierarchy, and the organization of
the packages. In particular this release ships with 2 functional
servers (dods.servers.test.dts and dods.servers.test.drds), 1
functional client (dods.clients.geturl.Geturl), 2 special clients
(dods.clients.ascii and dods.clients.www) that get used in the
server architecture. The problems that Jake pointed out below about
Input/Output Stream's and Reader/Writer's still remain to be
resolved, and unfortunately this means that we are still using
deprecated API's in several places.**NOTE: The test suites are currently
broken. They did work, but changes in
test server (repeated identical calls for the same dataset will produce
different, although predictable, data) have rendered them non functional
for the time being.
Beta 1.0 (ndp)
At this time the Server side code has been written. Class hierarchies
have been cleaned up and in general the core code in the "dap" is
tight and clean. Many of the ancillary programs written by Jake have
not been extensively tested, this includes Geturl. The Server code
has been tested and seems to work well.
Note: The following may be completely out of date, but they are still
included as part of our legacy.
Jake's Original Design Notes
The following are some notes about the design
and implementation of
the Java DAP library. It should be useful reading for anyone who
needs to fix bugs or add features to this code.
Design Differences
The definitive documentation for the DAP is contained in the Javadoc
comments included with the source code. You can build this
documentation with the "make doc" target of the Makefile. Here are
some important differences between the API described in the Javadoc
comments, and the C++ version of DODS, as well as James Gallagher's
initial Java DAP design.
- Only the client-side design is implemented in this library. This
code can form a base for a Java DODS server, but several important
pieces of functionality will need be written. These include: the
Projection, RelOps and ServerIO interfaces from James' design, the
Function and ServerDDS classes, and the Constraint Evaluator (CE).
- Unlike
James' design, which had a single Attribute class, this implementation
features separate Attribute and AttributeTable classes,
which more closely correspond to the C++ implementation's AttrTable
class and its 'entry' structure.
- One weakness of the C++ implementation
is the lack of encapsulation for the different DODS types. In particular,
a number of core
classes, including BaseType.cc, have to be aware of every DODS type.
Also, being able to set and get the type of a variable overrides the
natural class hierarchy accessible in C++ through RTTI (which, in
fairness, wasn't available when the C++ DODS was written), and in Java
through the 'instanceof' operator. Therefore, when designing the Java
DAP, I ensured that the BaseType class has no special knowledge of
particular DODS types, and that adding new DODS types would be as easy
as possible. Information on doing so is described later in this file.
- As part
of the encapsulation requirement set forth in the previous point, I added
a new class, PrimitiveVector, to manage arrays of each
primitive BaseType. Each primitive type (DByte, DInt32, etc.) defines
its own PrimitiveVector class, which stores arrays of that primitive
type in a very compact form (byte[], int[], etc.). There is also a
generic BaseTypePrimitiveVector, which stores arrays of the DString
type, as well as more complex types (DStructure, etc.).
PrimitiveVector is public so that DODS clients can get and set the individual
values of each array type efficiently by retrieving the PrimitiveVector
object from the DVector and then casting it to the
appropriate child (BytePrimitiveVector, etc.).
- One source of many problems
in the C++ core was the implementation of Sequence. This table type is the
only DODS type which must be
deserialized repeatedly, once for each row of the table. While this
design may be useful when deserializing a very large dataset
asynchronously, it complicates the deserialization process for all
other types which have to deal with sequences. When designing the
Java core, I wrote DSequence to retrieve all rows of the table with a
single call to the deserialize method. Because there is currently no
asynchronous getData method (the entire dataset is retrieved fully
populated) in the Java core, the user of the Java core can be
confident that either they will have received the entire dataset from
the getData call, or an exception will be thrown. This vastly
simplifies usage of this library by clients. Users who might desire
the asynchronous deserialization approach should be able to get the
same result by using Java threads and the StatusUI interface.
Java Pitfalls
Here are some miscellaneous comments on particular aspects of Java
which I had to deal with when designing the Java DAP. Hopefully you
won't stumble into these pitfalls yourself if I mention them here:
- InputStream vs. Reader: The biggest change in the java.io package
between Java 1.0 and 1.1 was the addition of a number of new classes
based on the Reader and Writer abstract classes instead of the
InputStream and OutputStream abstract classes used in Java 1.0. This
addition is very confusing because many other areas of Java, including
the standard input and output (System.in, System.out, and System.err)
and the java.net classes (URLConnection's getInputStream method),
continue to support only the older InputStream and OutputStream.
Also, neither
class is a proper superset of the other: the DataInputStream class is the
only built in way to read binary values,
such as 'int' and 'double' types, while the BufferedReader provides
the only non-deprecated way to read a line of text as a String. It's
possible to wrap an InputStream with a Reader, but not possible to go
in the other direction.
Furthermore, the BufferedReader has the limitation of
reading ahead (or buffering, hence the name) in the stream, which means that
the
original InputStream can't be used after it has been wrapped in a
BufferedReader. This is why the DConnect class uses the deprecated
DataInputStream.readLine() method, because it must use the InputStream
as a DataInputStream (and not a Reader) later in the code. Using a
deprecated method is probably the easiest way to solve this problem,
and I'm explaining the reasoning in detail here in case a future
programmer is bothered by the use of a deprecated method. By the way,
the reason this method was deprecated is because it doesn't properly
handle Unicode: since the C++ version of DODS doesn't even attempt to
handle Unicode, I don't think this is a big concern!
- The JavaCC generated
parser classes perform their own buffering. Therefore it's not necessary
to use a BufferedReader or
BufferedInputStream. However, because of this lookahead, it was
necessary for me to write a line-buffering class called
HeaderInputStream to not allow the parser to read beyond the "Data:"
line. When reading data from DODS, the server sends the DDS, followed
by a "Data:" line, then the actual data. Without my HeaderInputStream
in the middle, the parser was reading the DDS, and buffering ahead all
of the data as well. HeaderInputStream is a very naive filter, and
could certainly be optimized for better performance, however I've not
profiled the code, so I don't know if it's a bottleneck or not.
- A note on
BufferedWriter: the DAS, DDS, and DataDDS print methods which take an OutputStream
parameter wrap it in a BufferedWriter for
better performance. This allows a simple client to pass System.out
directly to the print method and expect reasonable performance.
However, note the importance of calling the flush method on the
BufferedWriter before returning from the print method, or else the
data might not be output. Again, this is all handled by the DAP, but
if you use BufferedWriter in your own code, make sure to properly
flush the stream at regular intervals, or you might not see the output
you expected.
- A major component of the DAP is the use of the XDR library to
encode binary data in a platform independent manner. Fortunately, in Java,
there is little need for an XDR library, because the DataInputStream
class makes it easy to read XDR data. The only complexity is
reading the Byte types, because all XDR values are padded to a
multiple of 4 bytes, thus necessitating insertion of padding in bytes,
byte arrays, and strings. For more information on the XDR format,
look up the RFC 1014 Internet standard.
- DODS has support for unsigned types
(UInt32), while Java does not. However, it is possible to print a Java int
as if it were unsigned
through a clever trick: cast the int to a long (64-bit) and mask
off the sign bits:
long tempVal = ((long)val) & 0xFFFFFFFFL;
Therefore, the only significant difference between DInt32 and DUInt32
is in the print method, so the DUInt32 class inherits from DInt32.
The
above tip, and many other useful tips, are listed in the Java Programmers
FAQ, available here:
http://www.best.com/~pvdl/javafaq.html.
One interesting feature of the Java
DAP is that many of the classes implement the Cloneable interface. This
enables an entire DAS or DDS
to be cloned by a line like the following:
DAS newDAS = (DAS)oldDAS.clone();
The implementation of the clone method is different from the default
implementation supported by most Java classes in that it performs a
deep copy of all data contained in it. This means that once a DAS or
DDS is cloned, it is completely independent, and any future
modifications made to either class won't affect the other.
Thread safety
is an important, and underrated issue, affecting many Java programs. The
Java DAP is nominally threadsafe in that the
deserialize method is marked as 'synchronized', which means that only
one thread can load new data into a DDS at a time. This is not
strictly necessary because deserialization is normally handled behind
the scenes in a single thread of the core, but it may be useful in the
future. Also, there are no uses of global or static variables or
other inherently non-threadsafe designs in the core. In particular,
the "STATIC = false" option is supplied in all three JavaCC generated
parsers, which means that multiple instances of the parser can be run
at once without conflicting.
One use of the DAP which should be totally
threadsafe is reading multiple DAS's or DDS's at the same time, using separate
DConnect
objects (pointing to the same or different URL's). Trying to read the
DAS, DDS, and Data at the same time from the same DConnect object
should also work, since a new URLConnection is created inside the
method, but this hasn't been tested. Deserializing the DAS, DDS, or
Data while simultaneously reading out the values will probably not
work, but this is prevented by the design of DConnect, which only
returns fully downloaded DAS, DDS, or DataDDS objects.
If you need to debug
the parser code, you'll probably want to comment out the try/catch block
for ParseException in the parser
source (e.g. DASParser.jj for the DAS parser). This code catches an
exception thrown by the parser and rethrows a much more general
exception, which is probably less useful if you suspect a bug in the
parser itself. Temporarily commenting these lines out will return a
very specific error from the parser describing what line the error
occurred and which token or tokens were expected.
In the Java Geturl client,
you may notice particularly ugly printing of floating point values. For example,
0.3 prints as "
0.30000000000000004". This is because Java, by default, prints
floating point numbers to their full precision, such that reading the
ASCII version will produce a number bit for bit identical with the
original. It is possible to "pretty-print" floating point numbers
using the java.text.NumberFormat class, but I didn't use this, as it
doesn't support exponential notation for very large or very small numbers.
One
feature of Java is its support for Unicode characters. These are usually
sent over the network in UTF-8 format, which uses a single
byte to represent the 7-bit ASCII characters, and two or three bytes
to represent the other characters in the 16-bit Unicode format.
Unfortunately, Unicode support is not easy in C++, and DODS currently
provides no international character support. Theoretically, one could
use the upper 128 characters in the ISO Latin 1 codeset in the C++
DODS to represent all characters used in the Western European
languages, but in both C++ and Java, I've chosen to escape any
characters outside of the usual 7-bit printable ASCII range for
clarity. If international character support is needed in the future,
then I suggest that the Unicode UTF-8 encoding be adopted, and that
this be converted into whatever format is used by the native OS on the
C++ side.
If you'd like to use the DAP code in a Java applet, you'll need
to be aware of the security restrictions surrounding applets. In
particular, applets are normally only allowed to establish network
connections to the host from which they are downloaded. This
restriction was designed to prevent a malicious applet from contacting
hosts on your internal network and giving that information to an
attacker outside the firewall. However, for DODS, this restriction is
unfortunate, because a Java DODS applet may want to communicate with
many different DODS servers. In this case, you can use a signed
applet which asks the user for permission to relax this security
restriction. The alternate would be to write a DODS proxy server to
sit on the Web server and retrieve DODS URL's from the other sites
which the applet can't directly access.
Testing
Here is some information about the test cases written for this code:
- The das-check and dds-check testsuites were ported almost directly
from the C++ code. The fact that the testsuite returns identical
results to the C++ version is a testament to the compatibility between
the two versions.
- The dap-check target is a new test program to programmatically
construct a DAS and DDS, fill them with data, clone them (thus testing
the Cloneable interface), and verify the original contents.
- The server-check
target is a port of the C++ HDF DODS server, and unlike the other tests,
returns slightly different results from its
C++ counterpart. The primary difference is that floating point values
print slightly differently in Java (more digits of precision).
Another difference is that the order in which DAS attributes are
printed is occasionally different from the C++ version, due to the use
of a C++ map class (DASVHMap) which doesn't always preserve the order
in which the DAS was downloaded. Finally, there are a few
inconsistencies in the C++ printing of Sequence (indentation of braces
is inconsistent) and UInt32 (printed as "Uint32" in C++) which the
Java version corrects.
- Areas which have not been tested include the old Sequence
deserialize protocol and deserializing a Function. This should not
present a big concern because the code is straightforward enough that
it should work, and because both cases are somewhat rare (the old
Sequence protocol was buggy and limited, so servers using it should be
upgraded anyway, and the DODS Function type has been deprecated).
Adding New Types To The Dap
Unlike the C++ version of DODS, the Java DAP port was designed to make
it easy to add new data types to the core. Here are the places where
the code will need to be changed to incorporate a new primitive type:
- Add the new type as a class inheriting from BaseType. Implement all
required methods, using an existing class, like DInt32, as an example.
- Add a new PrimitiveVector class to handle arrays of the new type. See
Int32PrimitiveVector as an example. Your new type class will
return this new vector type in its newPrimitiveVector method.
- Add methods
to the BaseTypeFactory interface and DefaultFactory class to construct a
new instance of your type. See the existing
methods as an example.
- Add code to the DDSParser.jj to recognize your new
type when listed in a DAS or DDS.
- If your type is a primitive type which
you want to allow in a DAS Attribute, then edit the Attribute class and DASParser.jj
to recognize
your new type when converted to String form.
- If you have written a Java
DODS server (which is not currently possible, since only the client portion
of the DAP is implemented in
Java), then you may want to add this type to the list that is
currently served.
- If you have written a Java DODS client which has detailed
knowledge of the DODS types (unavoidable unless you want to limit yourself
to
printing out the data in ASCII, as Geturl does), then you will need to
add knowledge of the new data type to your client.Jake Hamby<EMAIL_ADDRESS>NASA/JPL October 1998


Extendedkit is a CSS framework based on UIkit that allows you to use the following colors without using SASS or LESS.
Of course, you can use all of UIkit's original classes and features as well.
See changes for details.
If you find a bug or other issue, please contact us via the contact form or Git-Hub.
Download Extendedkit, css file in css directry, js file in js directry AND add the following codes
download<link rel="stylesheet" href="css/e-kit.min.css" />
<script src="js/e-kit.min.js"></script>
<script src="js/e-kit-icons.min.js"></script>
Making Now...
Copyright(c)2020- Rikuya All Rights Reserved


Demonstration of the Ontology visualisation: example 1
This is an example with a
minimum set of options, therefore demonstrating the 'default options'. The visualisation connects to EBI's OLS service to fetch the data for the term 'aggregation of unicellular organisms' in the GO ontology.
Questions, issues, bug reports or general feedback? Please use
github


{% macro project_item(project) %} {% set placeHolderPriority = project.priority | d('5') %}
{% endmacro %} {% macro project_header() %}On-going work to seek steers from Ministers to inform regulations and delivery.
Programme: None
Due Date
November 2016
Minister
Lord Freud
SRO
Susan Parks
In the Summer Budget 2015, the Chancellor set out a package of reforms to deliver the welfare savings the Government commited to in its election manifesto; set out in The Welfare Reform and Work Act 2016.


Name: Jean-Charles
Location: Boston
Other Skills: Having "nice guy" hair
More Other Skills: being humble
Get it? Hah
Name: Jean-Charles
Location: Boston
Other Skills: Having "nice guy" hair
More Other Skills: being humble
Food: Lasagna
Word: Onomatopoeia
Country song: …
Person in this room: You :sappycat:
Winter olympics sport: Ice sculpting
Dad Joke:
Did you hear about my corduroy pillow? No? But it made headlines …
First, here's some stuff you already know.
Git is a decentralized version control system.
By default, when you clone, you'll have the complete repository history.
Git leverages an intermediate index.
You add into and commit from your index.
gitconfig, aliases, and git- executables
git notes or
how to avoid "wtf was I thinking?!"
git stash to avoid WIP
Stash objects can be treated like other git objects
hub - it brings the 'hub to git
duh
tig, pushing to multiple remotes at once, git reflog, instaweb …
First, here's more stuff you already know.
GitHub is a GUI web frontend to Git.
By default, when you clone, you'll have the complete repository history.
URL modifiers (?w=1, .patch, .diff)
Mentioning issues, closing automatically, etc
Checkboxes in PRs
keyboard shortcuts ("y"!), pasting images, gists as repos, ranged linking, fenced code blocks, …
First, even more stuff you already know.
The dev tools are a means of inspecting and debugging your web applications.
It's functions include a client-side JS step debugger, element and style inspection, memory and cpu profilers, etc.
As UIEs, the dev tools are amongst the most powerful tools in our toolbox.
Workspaces turn Chrome into a complete IDE
Snippets are like bookmarklets that live inside dev tools
log isn't the only method available to the console
CPU and Memory profiling, "H" keyboard shortcut, "copy" console command, paint rectangles, $0 …
Now I want to talk to you about some new stuff.
Just kidding, this is stuff you already know.
Node.js (henceforth, "node") is a software platform that uses v8 as a JavaScript run-time and libuv to perform cross-platform, async I/O.
It intends to provide you with the minimum set of tooling to write an application and little more.
The built-in step debugger - not great but not terrible
npm link
I know, it's not node but it's basically node
Nothing. You just learned everything there is to know about node.
Not really but that's kind of the point.
That's it.


{% extends "dataset/base.html" %} {% block content %}
Linking human motion and natural language is of great interest for the generation of semantic representations of human activities as well as for the generation of robot activities based on natural language input. However, while there have been years of research in this area, no standardized and openly available dataset exists to support the development and evaluation of such systems. We therefore propose the The KIT Motion-Language Dataset, which is large, open, and extensible.
| Date | Number of Motions | Number of Annotations | Size | Download |
|---|---|---|---|---|
| {{ dataset.creation_date | date }} {% if forloop.counter0 == 0 %}Latest{% endif %} | {{ dataset.nb_motions }} | {{ dataset.nb_annotations }} | {{ dataset.filesize | filesizeformat }} | {{ dataset.filename }} |
@article{DBLP:journals/corr/PlappertMA16, author = {Matthias Plappert and Christian Mandery and Tamim Asfour}, title = {The {KIT} Motion-Language Dataset}, journal = {CoRR}, volume = {abs/1607.03827}, year = {2016}, url = {http://arxiv.org/abs/1607.03827}, timestamp = {Tue, 02 Aug 2016 12:59:27 +0200}, biburl = {http://dblp.uni-trier.de/rec/bib/journals/corr/PlappertMA16}, bibsource = {dblp computer science bibliography, http://dblp.org} }
The content of the extracted dataset looks like this:
00001_annotations.json 00001_meta.json 00001_mmm.xml 00001_raw.c3d 00002_annotations.json 00002_meta.json 00002_mmm.xml 00002_raw.c3d 00003_annotations.json 00003_meta.json 00003_mmm.xml 00003_raw.c3d ... 03966_annotations.json 03966_meta.json 03966_mmm.xml 03966_raw.c3d
Each file is prefixed with an ID followed by its type: <id>_<type>.<ext>
. Please notice that the IDs are not necessarily consecutive. However, each ID is unique and for each ID, there are always exactly four types of files. The format and contents of the available files are explained below.
<id>_raw.<ext>
)The format of the raw motion data depends on the data source. Currently, the dataset only contains C3D files. However, since this might change in the future, we recommend that you use the unified MMM representation instead.
Currently, our dataset contains motion data from the following data sources:
<id>_mmm.xml
)The motions are available as XML files that represent the motion using the Master Motor Map (MMM) framework. We recommend that you always use this file when working with the motion data since it abstracts from the concrete motion capture system in use and allows you to use new data sources in the future without effort. An comprehensive documentation of the data format is available on the MMM website. Please refer to this documentation for details. We also provide a simple Python example (see below) that parses the most important parts of the XML file without any third-party dependencies.
<?xml version='1.0'?>
<MMM>
<Motion name='subject_id_4'>
<Model>
<File>mmm.xml</File>
</Model>
<ModelProcessorConfig type='Winter'>
<Height>1.82</Height>
<Mass>100</Mass>
</ModelProcessorConfig>
<JointOrder>
<Joint name='BLNx_joint'/>
<Joint name='BLNy_joint'/>
<Joint name='BLNz_joint'/>
<Joint name='BPx_joint'/>
<Joint name='BPy_joint'/>
<Joint name='BPz_joint'/>
<Joint name='BTx_joint'/>
<Joint name='BTy_joint'/>
<Joint name='BTz_joint'/>
<Joint name='BUNx_joint'/>
<Joint name='BUNy_joint'/>
<Joint name='BUNz_joint'/>
<Joint name='LAx_joint'/>
<Joint name='LAy_joint'/>
<Joint name='LAz_joint'/>
<Joint name='LEx_joint'/>
<Joint name='LEz_joint'/>
<Joint name='LHx_joint'/>
<Joint name='LHy_joint'/>
<Joint name='LHz_joint'/>
<Joint name='LKx_joint'/>
<Joint name='LSx_joint'/>
<Joint name='LSy_joint'/>
<Joint name='LSz_joint'/>
<Joint name='LWx_joint'/>
<Joint name='LWy_joint'/>
<Joint name='LFx_joint'/>
<Joint name='LMrot_joint'/>
<Joint name='RAx_joint'/>
<Joint name='RAy_joint'/>
<Joint name='RAz_joint'/>
<Joint name='REx_joint'/>
<Joint name='REz_joint'/>
<Joint name='RHx_joint'/>
<Joint name='RHy_joint'/>
<Joint name='RHz_joint'/>
<Joint name='RKx_joint'/>
<Joint name='RSx_joint'/>
<Joint name='RSy_joint'/>
<Joint name='RSz_joint'/>
<Joint name='RWx_joint'/>
<Joint name='RWy_joint'/>
<Joint name='RFx_joint'/>
<Joint name='RMrot_joint'/>
</JointOrder>
<MotionFrames>
<MotionFrame>
<Timestep>0</Timestep>
<RootPosition>1142.97 -252.854 973.526</RootPosition>
<RootRotation>-0.0735726 -0.0238353 1.64312</RootRotation>
<JointPosition>-0.612953 0.0476239 0.212333 0.161793 0.0028466 0.0190509 -0.0479624 -0.0228922 -0.0694337 0.387513 -0.0018089 0.135106 0.158669 -0.324085 -0.165832 0.35672 -0.0738947 0.103075 0.0545089 0.135437 -0.221003 -0.154341 0.179823 -0.279305 0.0844597 -0.254741 -0.122429 0.224831 0.0616969 0.324959 -0.483339 0.308075 0.857774 0.00596291 0.0430199 0.373412 -0.021832 -0.11818 -0.083582 -0.152354 0.120838 0.373251 -0.0313812 -0.261799 </JointPosition>
<JointVelocity>0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 </JointVelocity>
<JointAcceleration>0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 </JointAcceleration>
</MotionFrame>
<MotionFrame>
<Timestep>0.01</Timestep>
<RootPosition>1142.89 -252.863 973.795</RootPosition>
<RootRotation>-0.0752048 -0.0231932 1.64472</RootRotation>
<JointPosition>-0.651594 -0.142824 0.211258 0.17367 0.000509898 0.0173047 -0.0596829 -0.0227031 -0.0701363 0.471133 0.261797 0.116722 0.155988 -0.323779 -0.172119 0.356309 -0.0834862 0.106037 0.0545055 0.139367 -0.222049 -0.151358 0.178517 -0.269665 0.0925315 -0.257984 -0.113151 0.221422 0.0603637 0.326164 -0.478189 0.309305 0.879796 0.00786525 0.0430097 0.363636 -0.0238971 -0.115228 -0.0827109 -0.163222 0.134703 0.373612 -0.021385 -0.261799 </JointPosition>
<JointVelocity>0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 </JointVelocity>
<JointAcceleration>0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 </JointAcceleration>
</MotionFrame>
<!-- More <MotionFrame> elements follow -->
</MotionFrames>
</Motion>
</MMM>
<id>_annotations.json
)The annotations for each motion are available as strings in a very simple JSON array. One motion can have many motions. Notice also that we include motions that haven't been annotated yet in the dataset, which means that the array may also contain zero elements.
[
"A person walks.",
"a person walks four steps forward"
]
<id>_meta.json
)The metadata for each entry is provided as a simple JSON dictionary. It links each entry to the Motion Annotation Tool and to the source database of the motion. This information is useful if you need to look up additional data from the database, e.g. the subject's height or weight. It also contains the perplexity of each annotation under a simple 3-gram language model. This allows you to find and filter out outliers.
{
"motion_annotation_tool":{
"id":3966,
"annotation_ids":[
5524
]
},
"source":{
"mirror_database":{
"identifier":"kit",
"motion_file_id":53570,
"motion_id":1149
},
"institution":{
"identifier":"cmu",
"name":"Carnegie Mellon University"
},
"database":{
"identifier":"cmu",
"motion_file_id":38,
"motion_id":127
}
},
"nb_annotations":1,
"annotation_perplexities":[2.78172, 7.43163]
}
Notice that the mirror_database
entry is not always available.
You can use the Ice interface of the KIT Whole-Body Human Motion Database to obtain additional information on each motion. The Ice interface can be used with a wide variety of different programming and scripting languages. You can use the the motion_id
entry from the metadata dictionary to obtain the corresponding ID for each motion. Additional information as well as the necessary Ice interface specification is available here.
We provide a simple example that illustrates how the entire dataset can be loaded using Python. The only dependency that we use is numpy
.
import argparse
import os
import json
import xml.etree.cElementTree as ET
import logging
import numpy as np
def parse_motions(path):
xml_tree = ET.parse(path)
xml_root = xml_tree.getroot()
xml_motions = xml_root.findall('Motion')
motions = []
if len(xml_motions) > 1:
logging.warn('more than one <Motion> tag in file "%s", only parsing the first one', path)
motions.append(_parse_motion(xml_motions[0], path))
return motions
def _parse_motion(xml_motion, path):
xml_joint_order = xml_motion.find('JointOrder')
if xml_joint_order is None:
raise RuntimeError('<JointOrder> not found')
joint_names = []
joint_indexes = []
for idx, xml_joint in enumerate(xml_joint_order.findall('Joint')):
name = xml_joint.get('name')
if name is None:
raise RuntimeError('<Joint> has no name')
joint_indexes.append(idx)
joint_names.append(name)
frames = []
xml_frames = xml_motion.find('MotionFrames')
if xml_frames is None:
raise RuntimeError('<MotionFrames> not found')
for xml_frame in xml_frames.findall('MotionFrame'):
frames.append(_parse_frame(xml_frame, joint_indexes))
return joint_names, frames
def _parse_frame(xml_frame, joint_indexes):
n_joints = len(joint_indexes)
xml_joint_pos = xml_frame.find('JointPosition')
if xml_joint_pos is None:
raise RuntimeError('<JointPosition> not found')
joint_pos = _parse_list(xml_joint_pos, n_joints, joint_indexes)
return joint_pos
def _parse_list(xml_elem, length, indexes=None):
if indexes is None:
indexes = range(length)
elems = [float(x) for idx, x in enumerate(xml_elem.text.rstrip().split(' ')) if idx in indexes]
if len(elems) != length:
raise RuntimeError('invalid number of elements')
return elems
def main(args):
input_path = args.input
print('Scanning files ...')
files = [f for f in os.listdir(input_path) if os.path.isfile(os.path.join(input_path, f)) and f[0] != '.']
basenames = list(set([os.path.splitext(f)[0].split('_')[0] for f in files]))
print('done, {} potential motions and their annotations found'.format(len(basenames)))
print('')
# Parse all files.
print('Processing data in "{}" ...'.format(input_path))
all_ids = []
all_motions = []
all_annotations = []
all_metadata = []
reference_joint_names = None
for idx, basename in enumerate(basenames):
print(' {}/{} ...'.format(idx + 1, len(basenames))),
# Load motion.
mmm_path = os.path.join(input_path, basename + '_mmm.xml')
assert os.path.exists(mmm_path)
joint_names, frames = parse_motions(mmm_path)[0]
if reference_joint_names is None:
reference_joint_names = joint_names[:]
elif reference_joint_names != joint_names:
print('skipping, invalid joint_names {}'.format(joint_names))
continue
# Load annotation.
annotations_path = os.path.join(input_path, basename + '_annotations.json')
assert os.path.exists(annotations_path)
with open(annotations_path, 'r') as f:
annotations = json.load(f)
# Load metadata.
meta_path = os.path.join(input_path, basename + '_meta.json')
assert os.path.exists(meta_path)
with open(meta_path, 'r') as f:
meta = json.load(f)
assert len(annotations) == meta['nb_annotations']
all_ids.append(int(basename))
all_motions.append(np.array(frames, dtype='float32'))
all_annotations.append(annotations)
all_metadata(meta)
print('done')
assert len(all_motions) == len(all_annotations)
assert len(all_motions) == len(all_ids)
print('done, successfully processed {} motions and their annotations'.format(len(all_motions)))
print('')
# At this point, you can do anything you want with the motion and annotation data.
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='')
parser.add_argument('input', type=str)
main(parser.parse_args())
Notice that this only parses the joint values of the MMM file. You can also use the MMM framework to do much more with the data. Please refer to the MMM documentation for details.


Will you pay the claimant as set out in the judgment?
{% if data['ccjpaymenttype'] == 'setdate' and data['afterccjdeadline'] == 'true' %}The judgment says you must pay £1,500 by {{ now | date("add", 25, "day") | date( "D MMMM YYYY" ) }}.
{% elif data['ccjpaymenttype'] == 'setdate' and data['afterccjdeadline'] == 'false' %}The judgment says you must pay £1,500 by {{ now | date("add", 25, "day") | date( "D MMMM YYYY" ) }}.
If you pay in full before 4pm on {{ now | date("add", 23, "day") | date( "D MMMM YYYY" ) }}, and {{ partyName( 'claimant' ) }} confirms it, the CCJ will be removed from the public register.
{% elif data['ccjpaymenttype'] == 'instalments' and data['afterccjdeadline'] == 'true' %}The judgment says you owe {{ partyName( 'claimant' ) }} £1,500. You must pay in instalments of £200 per month.
{% elif data['ccjpaymenttype'] == 'instalments' and data['afterccjdeadline'] == 'false' %}The judgment says you owe {{ partyName( 'claimant' ) }} £1,500. You must pay in instalments of £200 per month.
If you pay the full £1,500 before 4pm on {{ now | date("add", 23, "day") | date( "D MMMM YYYY" ) }}, and {{ partyName( 'claimant' ) }} confirms it, the CCJ will be removed from the public register.
{% elif data['ccjpaymenttype'] == 'immediately' and data['afterccjdeadline'] == 'false' %}The judgment says you must pay £1,500 immediately.
If you pay in full before 4pm on {{ now | date("add", 23, "day") | date( "D MMMM YYYY" ) }}, and {{ partyName( 'claimant' ) }} confirms it, the CCJ will be removed from the public register.
{% else %}The judgment says you must pay £1,500 immediately.
{% endif %}


|
LiteSQL
0.3.17
|
A base class of databases. More...
#include <database.hpp>
Classes | |
| class | SchemaItem |
| intermediate representation of single entity in relational database, table, index or sequence More... | |
Public Member Functions | |
| Database (const string &backendType, const string &connInfo) | |
| opens connection to backend, throw exception if fails or cannot found a Backend class More... | |
| Database (const Database &op) | |
| opens new connection to same database More... | |
| virtual | ~Database () |
| closes database | |
| void | create () const |
| creates database based on getSchema | |
| void | drop () const |
| converts CREATE-statements (of getSchema) to DROP statements and executes them | |
| bool | needsUpgrade () const |
| returns true if schema of backend database is different from schema returned by getSchema. More... | |
| void | upgrade () const |
| tries to upgrade database on disk so that schemas would be compatible | |
| Records | query (const string &query) const |
| executes SQL query More... | |
| template<class T > | |
| Cursor< T > | cursor (const string &query) const |
| void | insert (const string &table, const Record &r, const Split &fields=Split()) const |
| executes SQL INSERT statement. More... | |
| string | groupInsert (const Record &tables, const Records &fields, const Records &values, const string &sequence) const |
| executes multiple INSERT-statements and assigns same 'row id' for first field of every record More... | |
| void | delete_ (const string &table, const Expr &e=Expr()) const |
| deletes rows from single table, deleted rows are selected by Expr if specified More... | |
| void | begin () const |
| begins SQL transaction | |
| void | commit () const |
| commits SQL transaction | |
| void | rollback () const |
| cancels active SQL transaction | |
Public Attributes | |
| bool | verbose |
| verbosity, prints queries to cerr if true | |
Protected Member Functions | |
| void | storeSchemaItem (const SchemaItem &s) const |
| stores SchemaItem to 'schema' - table (deletes old versions) | |
| virtual std::vector< SchemaItem > | getSchema () const |
| returns database schema. More... | |
| std::vector< SchemaItem > | getCurrentSchema () const |
| queries 'schema' - table and converts results to SchemaItem-objects More... | |
| void | upgradeTable (string name, string oldSchema, string newSchema) const |
| adds missing and removes extra fields to/from table (tries to preserve data). More... | |
| bool | addColumn (const string &name, const ColumnDefinition &column_def) const |
Protected Attributes | |
| Backend * | backend |
| backend implementation | |
Friends | |
| class | Updater |
A base class of databases.
Can be used without inheriting own version of Database using query()-method. See Defining Database
| litesql::Database::Database | ( | const string & | backendType, |
| const string & | connInfo | ||
| ) |
opens connection to backend, throw exception if fails or cannot found a Backend class
| backendType | backend type ("postgresql","mysql" or "sqlite3") |
| connInfo | connection params, syntax "param=value param=value ..." valid keys: host,user,password,database and port |
| litesql::Database::Database | ( | const Database & | op | ) |
opens new connection to same database
| op | opened Database |
|
protected |
queries 'schema' - table and converts results to SchemaItem-objects
References litesql::replace().
Referenced by needsUpgrade(), and upgrade().
|
inlineprotectedvirtual |
returns database schema.
Referenced by create(), drop(), needsUpgrade(), and upgrade().
| string litesql::Database::groupInsert | ( | const Record & | tables, |
| const Records & | fields, | ||
| const Records & | values, | ||
| const string & | sequence | ||
| ) | const |
executes multiple INSERT-statements and assigns same 'row id' for first field of every record
| tables | destination tables for insert operation |
| fields | record of field names per table |
| values | record of values per table |
| sequence | sequence where row id-numbers are pulled |
References backend, litesql::Backend::groupInsert(), litesql::Split::join(), and verbose.
| void litesql::Database::insert | ( | const string & | table, |
| const Record & | r, | ||
| const Split & | fields = Split() |
||
| ) | const |
executes SQL INSERT statement.
| table | destination table |
| r | values |
| fields | field names Values are escaped using escapeSQL - function |
References litesql::escapeSQL(), litesql::Split::join(), and query().
| bool litesql::Database::needsUpgrade | ( | ) | const |
returns true if schema of backend database is different from schema returned by getSchema.
References getCurrentSchema(), and getSchema().
| Records litesql::Database::query | ( | const string & | query | ) | const |
executes SQL query
| query | query string |
References backend, litesql::Backend::execute(), and verbose.
Referenced by litesql::DataSource< T >::count(), create(), delete_(), drop(), insert(), and upgrade().
|
protected |
adds missing and removes extra fields to/from table (tries to preserve data).
copies data to a temporary table and then back to upgraded table because all backends do not support ALTER TABLE ADD ... - SQL statements.
| name | table name |
| oldSchema | current schema of table |
| newSchema | upgraded schema of table |
References litesql::Split::join().
Referenced by upgrade().