Threading¶
Introduction¶
This chapter explains how to use PhysX in multithreaded applications. There are three main aspects to using PhysX with multiple threads:
- how to make read and write calls into the PhysX API from multiple threads without causing race conditions.
- how to use multiple threads to accelerate simulation processing.
- how to perform asynchronous simulation, and read and write to the API while simulation is being processed.
Data Access from Multiple Threads¶
For efficiency reasons, PhysX does not internally lock access to its data structures by the application, so be careful when calling the API from multiple application threads. The rules are as follows:
- API interface methods marked 'const' are read calls, other API interface methods are write calls.
- API read calls may be made simultaneously from multiple threads.
- Objects in different scenes may be safely accessed by different threads.
- Different objects outside a scene may be safely accessed from different threads. Be aware that accessing an object may indirectly cause access to another object via a persistent reference (such as joints and actors referencing one another, an actor referencing a shape, or a shape referencing a mesh.)
Access patterns which do not conform to the above rules may result in data corruption, deadlocks, or crashes. Note in particular that it is not legal to perform a write operation on an object in a scene concurrently with a read operation to an object in the same scene. The checked build contains code which tracks access by application threads to objects within a scene, to try and detect problems at the point when the illegal API call is made.
Scene Locking¶
Each PxScene object provides a multiple reader, single writer lock that can be used to control access to the scene by multiple threads. This is useful for situations where the PhysX scene is shared between more than one independent subsystem. The scene lock provides a way for these systems to coordinate with each other without creating direct dependencies.
It is not mandatory to use the lock. If all access to the scene is from a single thread, using the lock adds unnecessary overhead. Even if you are accessing the scene from multiple threads, you may be able to synchronize the threads using a simpler or more efficient application-specific mechanism that guarantees your application meets the above conditions. However, using the scene lock has two potential benefits:
- If the PxSceneFlag::eREQUIRE_RW_LOCK is set, the checked build will issue a warning for any API call made without first acquiring the lock, or if a write call is made when the lock has only been acquired for read,
- The APEX SDK uses the scene lock to ensure that it shares the scene safely with your application.
There are four methods for for acquiring / releasing the lock:
void PxScene::lockRead(const char* file=NULL, PxU32 line=0);
void PxScene::unlockRead();
void PxScene::lockWrite(const char* file=NULL, PxU32 line=0);
void PxScene::unlockWrite();
Additionally there is an RAII helper class to manage these locks, see PxSceneLock.h.
Locking Semantics¶
There are precise rules regarding the usage of the scene lock:
- Multiple threads may read at the same time.
- Only one thread may write at a time, no thread may write if any threads are reading.
- If a thread holds a write lock then it may call both read and write API methods.
- Re-entrant read locks are supported, meaning a lockRead() on a thread that has already acquired a read lock is permitted. Each lockRead() must have a paired unlockRead().
- Re-entrant write locks are supported, meaning a lockWrite() on a thread that has already acquired a write lock is permitted. Each lockWrite() must have a paired unlockWrite().
- Calling lockRead() by a thread that has already acquired the write lock is permitted and the thread will continue to have read and write access. Each lock*() must have an associated unlock*() that occurs in reverse order.
- Lock upgrading is not supported - a lockWrite() by a thread that has already acquired a read lock is not permitted. Attempting this in checked builds will result in an error, in release builds it will lead to deadlock.
- Writers are favored - if a thread attempts a lockWrite() while the read lock is acquired it will be blocked until all readers leave. If new readers arrive while the writer thread is blocked they will be put to sleep and the writer will have first chance to access the scene. This prevents writers being starved in the presence of multiple readers.
- If multiple writers are queued then the first writer will receive priority, subsequent writers will be granted access according to OS scheduling.
Note: PxScene::release() automatically attempts to acquire the write lock, it is not necessary to acquire it manually before calling release().
Locking Best Practices¶
It is often useful to arrange your application to acquire the lock a single time to perform multiple operations. This minimizes the overhead of the lock, and in addition can prevent cases such as a sweep test in one thread seeing a rag doll that has been only partially inserted by another thread.
Clustering writes can also help reduce contention for the lock, as acquiring the lock for write will stall any other thread trying to perform a read access.
Asynchronous Simulation¶
PhysX simulation is asynchronous by default. Start simulation by calling:
scene->simulate(dt);
When this call returns, the simulation step has begun in a separate thread. While simulation is running, you can still make calls into the API. Where those calls affect simulation state, the results will be buffered and reconciled with the simulation results when the simulation step completes.
To wait until simulation completes, call:
scene->fetchResults(true);
The boolean parameter to fetchResults denotes whether the call should wait for simulation to complete, or return immediately with the current completion status. See the API documentation for more detail.
It is important to distinguish two time slots for data access:
- After the call to PxScene::fetchResults() has returned and before the next PxScene::simulate() call (see figure below, blue area "1").
- After the call to PxScene::simulate() has returned and before the corresponding PxScene::fetchResults() call (see figure below, green area "2").
In the first time slot, the simulation is not running and there are no restrictions for reading or writing object properties. Changes to the position of an object, for example, are applied instantaneously and the next scene query or simulation step will take the new state into account.
In the second time slot the simulation is running and in the process, reading and changing the state of objects. Concurrent access from the user might corrupt the state of the objects or lead to data races or inconsistent views in the simulation code. Hence the simulation code's view of the objects is protected from API writes, and any attributes the simulation updates are buffered to allow API reads. The consequences will be discussed in detail in the next section.
Note that simulate() and fetchResults() are write calls on the scene, and as such it is illegal to access any object in the scene while these functions are running.
Double Buffering¶
While a simulation is running, PhysX supports read and write access to objects in the scene (with some exceptions, see further below). This includes adding/removing them to/from a scene.
From the user perspective, API changes are reflected immediately. For example, if the velocity of a rigid body is set and then queried, the new velocity will be returned. Similarly, if an object is created while the simulation is running, it can be accessed/modified as any other object. However, these changes are buffered so that the simulation code sees the object state as it was when PxScene::simulate() was called. For instance, changes to the filter data of an object while the simulation is running are ignored for collision pair generation of the running step, and will only affect for the next simulation step.
When PxScene::fetchResults() is called, any buffered changes are flushed: changes made by the simulation are reflected in API view of the objects, and API changes are made visible to the simulation code for the next step. User changes take precedence: for example, a user change to the position of an object while the simulation is running will overwrite the position which resulted from the simulation.
The delayed application of updates does not affect scene queries, which always take into account the latest changes.
Events involving removed objects¶
Deleting objects or removing them from the scene while the simulation is in process will affect the simulation events sent out at PxScene::fetchResults(). The behavior is as follows:
- PxSimulationEventCallback::onWake(), ::onSleep() events will not get fired if an object is involved which got deleted/removed during the running simulation.
- PxSimulationEventCallback::onContact(), ::onTrigger() events will get fired if an object is involved which got deleted/removed during the running simulation. The deleted/removed object will be marked as such (see PxContactPairHeaderFlag::eREMOVED_ACTOR_0, PxContactPairFlag::eREMOVED_SHAPE_0, PxTriggerPairFlag::eREMOVED_SHAPE_TRIGGER). Furthermore, if PxPairFlag::eNOTIFY_TOUCH_LOST, ::eNOTIFY_THRESHOLD_FORCE_LOST events were requested for the pair containing the deleted/removed object, then these events will be created.
Memory Considerations¶
The buffers to store the object changes while the simulation is running are created on demand. If memory usage concerns outweigh the advantage of reading/writing objects in parallel with simulation, do not write to objects while the simulation is running.
Multithreaded Simulation¶
PhysX includes a task system for managing CPU and GPU compute resources. Tasks are created with dependencies so that they are resolved in a given order, when ready they are then submitted to a user-implemented dispatcher for execution.
Middleware products typically do not want to create CPU threads for their own use. This is especially true on consoles where execution threads can have significant overhead. In the task model, the computational work is broken into jobs that are submitted to the application's thread pool as they become ready to run.
The following classes comprise the CPU task management.
TaskManager¶
A TaskManager manages inter-task dependencies and dispatches ready tasks to their respective dispatcher. There is a dispatcher for CPU tasks and GPU tasks assigned to the TaskManager.
TaskManagers are owned and created by the SDK. Each PxScene will allocate its own TaskManager instance which users can configure with dispatchers through either the PxSceneDesc or directly through the TaskManager interface.
CpuDispatcher¶
The CpuDispatcher is an abstract class the SDK uses for interfacing with the application's thread pool. Typically, there will be one single CpuDispatcher for the entire application, since there is rarely a need for more than one thread pool. A CpuDispatcher instance may be shared by more than one TaskManager, for example if multiple scenes are being used.
PhysX includes a default CpuDispatcher implementation, but we prefer applications to implement this class themselves so PhysX and APEX can efficiently share CPU resources with the application.
Note
The TaskManager will call CpuDispatcher::submitTask() from either the context of API calls (aka: scene::simulate()) or from other running tasks, so the function must be thread-safe.
An implementation of the CpuDispatcher interface must call the following two methods on each submitted task for it to be run correctly:
baseTask->run(); // optionally call runProfiled() to wrap with PVD profiling events
baseTask->release();
The PxExtensions library has default implementations for all dispatcher types, the following code snippets are taken from SampleBase and show how the default dispatchers are created. mNbThreads which is passed to PxDefaultCpuDispatcherCreate defines how many worker threads the CPU dispatcher will have.:
PxSceneDesc sceneDesc(mPhysics->getTolerancesScale());
[...]
// create CPU dispatcher which mNbThreads worker threads
mCpuDispatcher = PxDefaultCpuDispatcherCreate(mNbThreads);
if(!mCpuDispatcher)
fatalError("PxDefaultCpuDispatcherCreate failed!");
sceneDesc.cpuDispatcher = mCpuDispatcher;
[...]
mScene = mPhysics->createScene(sceneDesc);
Note
Best performance is usually achieved if the number of threads is less than or equal to the available hardware threads of the platform you are running on, creating more worker threads than hardware threads will often lead to worse performance. For platforms with a single execution core, the CPU dispatcher can be created with zero worker threads (PxDefaultCpuDispatcherCreate(0)). In this case all work will be executed on the thread that calls PxScene::simulate(), which can be more efficient than using multiple threads.
Note
CudaContextManagerDesc support appGUID now. It only works on release build. If your application employs PhysX modules that use CUDA you need to use a GUID so that patches for new architectures can be released for your application. You can obtain a GUID for your application from NVIDIA. The application should log the failure into a file which can be sent to NVIDIA for support.
CpuDispatcher Implementation Guidelines¶
After the scene's TaskManager has found a ready-to-run task and submitted it to the appropriate dispatcher it is up to the dispatcher implementation to decide how and when the task will be run.
Often in game scenarios the rigid body simulation is time critical and the goal is to reduce the latency from simulate() to the completion of fetchResults(). The lowest possible latency will be achieved when the PhysX tasks have exclusive access to CPU resources during the update. In reality, PhysX will have to share compute resources with other application tasks. Below are some guidelines to help ensure a balance between throughput and latency when mixing the PhysX update with other work.
- Avoid interleaving long running tasks with PhysX tasks, this will help reduce latency.
- Avoid assigning worker threads to the same execution core as higher priority threads. If a PhysX task is context switched during execution the rest of the rigid body pipeline may be stalled, increasing latency.
- PhysX occasionally submits tasks and then immediately waits for them to complete, because of this, executing tasks in LIFO (stack) order may perform better than FIFO (queue) order.
- PhysX is not a perfectly parallel SDK, so interleaving small to medium granularity tasks will generally result in higher overall throughput.
- If your thread pool has per-thread job-queues then queuing tasks on the thread they were submitted may result in more optimal CPU cache coherence, however this is not required.
For more details see the default CpuDispatcher implementation that comes as part of the PxExtensions package. It uses worker threads that each have their own task queue and steal tasks from the back of other worker's queues (LIFO order) to improve workload distribution.
BaseTask¶
BaseTask is the abstract base class for all task types. All task run() functions will be executed on application threads, so they need to be careful with their stack usage, use a little stack as possible, and they should never block for any reason.
Task¶
The Task class is the standard task type. Tasks must be submitted to the TaskManager each simulation step for them to be executed. Tasks may be named at submission time, this allows them to be discoverable. Tasks will be given a reference count of 1 when they are submitted, and the TaskManager::startSimulation() function decrements the reference count of all tasks and dispatches all Tasks whose reference count reaches zero. Before TaskManager::startSimulation() is called, Tasks can set dependencies on each other to control the order in which they are dispatched. Once simulation has started, it is still possible to submit new tasks and add dependencies, but it is up to the programmer to avoid race hazards. You cannot add dependencies to tasks that have already been dispatched, and newly submitted Tasks must have their reference count decremented before that Task will be allowed to execute.
Synchronization points can also be defined using Task names. The TaskManager will assign the name a TaskID with no Task implementation. When all of the named TaskID's dependencies are met, it will decrement the reference count of all Tasks with that name.
APEX uses the Task class almost exclusively to manage CPU resources. The ApexScene defines a number of named Tasks that the modules use to schedule their own Tasks (ex: start after LOD calculations are complete, finish before the PhysX scene is stepped).
LightCpuTask¶
LightCpuTask is another subclass of BaseTask that is explicitly scheduled by the programmer. LightCpuTasks have a reference count of 1 when they are initialized, so their reference count must be decremented before they are dispatched. LightCpuTasks increment their continuation task reference count when they are initialized, and decrement the reference count when they are released (after completing their run() function)
PhysX 3.x uses LightCpuTasks almost exclusively to manage CPU resources. For example, each stage of the simulation update may consist of multiple parallel tasks, when each of these tasks has finished execution it will decrement the reference count on the next task in the update chain. This will then be automatically dispatched for execution when its reference count reaches zero.
Note
Even when using LightCpuTasks exclusively to manage CPU resources, the TaskManager startSimulation() and stopSimulation() calls must be made each simulation step to keep the GpuDispatcher synchronized.
The following code snippets show how the crabs' A.I. in SampleSubmarine is run as a CPU Task. By doing so the Crab A.I. is run as a background Task in parallel with the PhysX simulation update.
For a CPU task that does not need handling of multiple continuations LightCpuTask can be subclassed. A LightCpuTask subclass requires that the getName and a run method be defined:
class Crab: public ClassType, public physx::PxLightCpuTask, public SampleAllocateable
{
public:
Crab(SampleSubmarine& sample, const PxVec3& crabPos, RenderMaterial* material);
~Crab();
[...]
// Implements LightCpuTask
virtual const char* getName() const { return "Crab AI Task"; }
virtual void run();
[...]
}
After PxScene::simulate() has been called, and the simulation started, the application calls removeReference() on each Crab task, this in turn causes it to be submitted to the CpuDispatcher for update. Note that it is also possible to submit tasks to the dispatcher directly (without manipulating reference counts) as follows:
PxLightCpuTask& task = &mCrab;
mCpuDispatcher->submitTask(task);
Once queued for execution by the CpuDispatcher, one of the thread pool's worker threads will eventually call the task's run method. In this example the Crab task will perform raycasts against the scene and update its internal state machine:
void Crab::run()
{
// run as a separate task/thread
scanForObstacles();
updateState();
}
It is safe to perform API read calls, such as scene queries, from multiple threads while simulate() is running. However, care must be taken not to overlap API read and write calls from multiple threads. In this case the SDK will issue an error, see Threading for more information.
An example for explicit reference count modification and task dependency setup:
// assume all tasks have a refcount of 1 and are submitted to the task manager
// 3 task chains a0-a2, b0-b2, c0-c2
// b0 shall start after a1
// the a and c chain have no dependencies and shall run in parallel
//
// a0-a1-a2
// \
// b0-b1-b2
// c0-c1-c2
// setup the 3 chains
for(PxU32 i = 0; i < 2; i++)
{
a[i].setContinuation(&a[i+1]);
b[i].setContinuation(&b[i+1]);
c[i].setContinuation(&c[i+1]);
}
// b0 shall start after a1
b[0].startAfter(a[1].getTaskID());
// setup is done, now start all task by decrementing their refcount by 1
// tasks with refcount == 0 will be submitted to the dispatcher (a0 & c0 will start).
for(PxU32 i = 0; i < 3; i++)
{
a[i].removeReference();
b[i].removeReference();
c[i].removeReference();
}


Chocolate Pizza
Posted on 15 Dec 2013 / Desserts
For the fig-swirl: Melt butter over medium heat in a saucepan. Add brown sugar and stir to dissolve. Halve all of the figs and toss in the saucepan with water and lemon juice. Cook over medium heat, stirring frequently, until you have a chunky-jammy mixture. Add salt with one or two stirs, set aside and let cool completely.
Ice cream: In a small pot over medium heat, combine milk, and granulated sugar until sugar is completely dissolved and the milk is just barely lukewarm. Whisk in the egg yolks. Set mixture in the fridge and wait until the fig mixture is cooled.
Using an ice cream machine, pour liquids into the frozen basin and p and process according to manufacturer instructions, i.e., let spin and thicken for 20 minutes before adding mascarpone, fig jam mixture, and the nuts. Continue to process for +/- 10 minutes. Pour semi-frozen mixture into a pyrex dish or glass tupperware. Freeze for at least two hours before serving.
Vannessa Stevenson
Food enthusiast, photography fan. Add a pinch of raw fooddism and that's pretty much who I am.


Meanwhile, somewhere in the Antipodes, longstanding Hooting Yard rapporteur Glyn Webster has devised a diagram showing the development of the modern metal tapping machine. It should be noted that the metal tapping machines occasionally mentioned in these pages bear greater resemblance to the one in the top left corner than to the one at bottom right. Click on the picture for a larger image.


Here are some lists of my favorite things in some categories
Youtube Channels
- Bill Wurtz
- Red Means Recording
- Simone Giertz
You might know him for his "History of Japan" video. In addition to his two longer videos, he's made a lot of shorter videos, all focused around a bit of music he's made.
This channel shows the process of making music on a synthesizer, but edited down so there's no boring parts. I don't know why, but I find the videos to be very relaxing.
She makes bad robots on purpose. They're actually pretty funny.
Programming Languages
- Python
- HTML/CSS
- JavaScript
I love python! The main downside is that it isn't compiled, so it can run slowly.
I wasn't a big fan of either until I did this project, but they're starting to grow on me. It's awesome to see a website slowly emerge as I work on it.
I don't know much about this language, but I hope to learn it and make this site more responsive or make a react-native app.


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
M.Cr.C. No.3327/2016 28.02.2017 Mrs. Preeti Waghmare, learned counsel for the applicant. Shri A.S. Parihar, learned counsel for the respondent No.2.
Shri Rausif Warsi, learned counsel for the respondent No.3. Shri N.L. Tiwari, learned counsel for the respondent No.4. Heard on I.A. No.3068/2016, which is an application u/S.5 of Limitation Act for condonation of delay.
This leave to appeal has been filed against the judgment of acquittal dated 18.11.2015 passed by JMFC, Badnawar, District- Dhar, in S.T. No.443/2007, whereby learned Magistrate acquitted the respondents from the charge u/S.44/47 of Water (Prevention and Control of Pollution) Act, 1974.
Learned counsel for the applicant submitted that M.P. Pollution control Boar is a body constituted for prevention and controal of pollution all over M.P.. They have to follow mandatory correspondence. There is a delay in filing this petition before this Court was due to departmental correspondence and was bonafide so delay is of 41 days be condoned.
Learned counsel for the respondent in his reply opposed the prayer and submitted that the applicant has not assigned any reason for day to day delay and delay is of 65 days and there was no mentioned as to why the regional office could not make any decision on time since the application is silent about the provisions under which it has been filed and prayed for rejection.
In this regard, learned counsel for the respondents placed reliance of Division Bench's judgment of this Court in the case of State of M.P. and another vs. M/s. Amar Construction Co. Sriji passed in Arbitration Revision No.03/2016, whereby this Court rejected the application filed u/S.5 of the Limitation Act, observing that respondents have not explain day to day delay but fact of this case is distinguishable, wherein delay was of 637 days while in the present case delay is only 41 days.
On the other hands, the apex Court in the case of Indian Oil Corporation Limited and others vs. Subrata Borah Chowlek and others reported in (2010) 14 SCC 419 held that satisfaction as to sufficient cause of delay- application and approach
- State vis-avis citizen, extent of parity- although exercise of power under S.5 depends upon judicial satisfaction and although no distinction is made between State and citizens, Courts, held, should be liberal while condoning delay in case of State which depends upon its officials for its actions. The apex Court also in the matter of Ganesharaju (dead) through Lrs. and another vs. Narasamma (dead) through Lrs. and others (2013) 11 SCC 341 also held that Limitation Act, 1963-S.5- sufficient cause- Liberal construction- held, the expression has to be given a liberal construction so as to advance substantial justice- unless the respondents are able to show mala fides in not approaching the court within the period of limitation, generally as a normal rule, delay should be condoned.
The application for condonation of delay cannot be rejected merely on the ground that it did not mentioned the provisions under which it filed the application.
In the present case delay is only 41 days and the applicant has clearly stated the reason for delay in his application. Only on the ground that the applicant has not mentioned the provisions under which it filed the application for condonation of delay, cannot be rejected.
Looking to the reason assigned by the applicant, the application is allowed and delay is of 41 days is hereby condoned.
Let the matter be listed after two weeks.
(RAJEEV KUMAR DUBEY) JUDGE JYOTI


?6
7
8
9
10
v
The
New
York
copyright
reserved
botanical
Garden
UNIVERSIDAD
DE
PUERTO
RICO
Herbario
UPRRP
c
h
r
y
sop
hy
Hum
Bauciflorujii
Lam.
PUERTO
RICO.
Coamo:
Bo.
Cuy—n,
Las
Piedras
Chiquitas,
along
bulldozed
road
from
house
at
Rt
717,
km
2.1,
to
U1
end
of
peaks.
Dry
scrub
forest.
Elev.
c.
450Ñ550
m.
Tree
(6-8
m).
Greenish
yellow
fl,
green
ellipsoidal
fr
.
F.
Axelrod
3499
30
Dec
1991
P.
Chavez
Sapotaceae
<3>ik
;aced
NEW
YORK
BOTANICAL
GARDEN
01028996
01028996
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Prof. Sartaj Sahni
Sartaj Sahni is a Distinguished Professor of Computer and Information Sciences and Engineering at the University of Florida. He is also a member of the European Academy of Sciences, a Fellow of IEEE, ACM, AAAS, and Minnesota Supercomputer Institute, and a Distinguished Alumnus of the IIT, Kanpur.
Prof. Murat Kantarcioglu
Murat is a Professor of Computer Science at University of Texas at Dallas and Director, UTD Data Security and Privacy Lab. His research focuses on creating technologies that can efficiently extract useful information from any data without sacrificing privacy or security. He has been working on security and privacy issues raised by data mining, privacy issues in social networks, applied cryptography for data security, etc.
Prof. Sigurd Meldal
Sigurd Meldal is a Professor and Director of Silicon Valley Big Data and Cybersecurity Center at San Jose State University, USA. As Director of the Cybersecurity + Big Data Initiative he is developing new research and graduate programs in cybersecurity and data sciences, exploiting the interplay of these two fields as well as their separate and distinct promises and challenges.
Dr. Rajeev Agrawal
Rajeev is Computer Scientist at U.S. Army Engineer Research and Development Center (ERDC). Previously he was an Associate Professor at North Carolina A&T State University. He is Machine Learning practitioner with research in the domain of medical datasets and online social media.
Prof. Sumeet Dua
Sumeet Dua is a Professor of Computer Science and Cyber Engineering and Director, Center for Secure Cyberspace, at Louisiana Tech University, LA. He leads the Data Mining Research Laboratory at Louisiana Tech and actively works in machine learning applications for the medical domain. He has authored several books on Data Mining and Machine Learning.
Prof. Oge Marques
Oge Marques is Professor in the Department of Computer and Electrical Engineering & Computer Science at Florida Atlantic University in Boca Raton, Florida. His research interests include: image processing, analysis, annotation, search, and retrieval; human and computer vision; and video processing and analysis. He is the author of 7 technical books, one patent, and more than 80 scientific articles in these topics.
Inderjit S. Dhillon
Inderjit Dhillon is the Gottesman Family Centennial Professor of Computer Science and Mathematics at UT Austin, where he is also the Director of the ICES Center for Big Data Analytics. He is an ACM Fellow, IEEE Fellow, SIAM Fellow, AAAS Fellow and has won the SIAM Linear Algebra Prize. Some of his current research topics: high-dimensional data analysis, divide-and- conquer methods for big data analytics, social network analysis, and predicting gene-disease associations.
P. Sadayappan
P. (Saday) Sadayappan is a Professor of Computer Science and Engineering at The Ohio State University. His research interests include compiler optimization for heterogeneous systems, domain/pattern-specific compiler optimization, characterization of data movement complexity of algorithms, and data-structure centric performance optimization. He obtained a Bachelors degree from IIT-Madras, and an M.S. and Ph.D. from Stony Brook University. He is a Fellow of the IEEE.
Chandrajit Bajaj
Chandrajit Bajaj is the director of the Center for Computational Visualization and a Professor of Computer Sciences at UT Austin. Bajaj holds the Computational Applied Mathematics Chair in Visualization. He is currently on the editorial boards for the International Journal of Computational Geometry and Applications and the ACM Computing Surveys. He is a Distinguished Alumnus of the Indian Institute of Technology, Delhi, (IIT Delhi). He is also a Fellow of AAAS, ACM, IEEE and SIAM.
Srinivasan Parthasarathy
Srinivasan Parthasarathy is a Professor of Computer Science and Engineering and the Director of the data mining research laboratory at Ohio State. His research interests span databases, data mining and high performance computing. He is among a handful of researchers nationwide (USA) to have won both the Department of Energy and National Science Foundation Career awards. He has won multiple best paper awards or "best of" nominations at ACM SIGKDD, VLDB, ISMB, WWW, ICDM, etc.


Temp:
Minimum Temperature:
Maximum Temperature:
Description of the weather conditions:
The wind speed:
Sunrise time:
Sunset time:


Hollowman9000
20-Sep-18 01:05 PM
So is the redeem script secret?
Because you’re just providing the hash of the redeem script, right?
Or is the whole redeem script in the transaction info
Original interest began with verus time-locked rewards in their p2sh addresses
And if it was possible to spoof a block height and prematurely gain access to time-locked rewards
Rather manually generate a transaction with a higher blockheight, and how it actually gets verified
I.e. say you privately forked it, ran the block height arbitrarily high, generated the tx, then broadcast it on the main chain
“It’s an older code sir, but it checks out”
Like I said, need to read more
Or if they’re simply time-locked, why the “b” address, couldn’t they have simply had the coins generated on a T address with a timelock, or was that done solely to obfuscate who mined what
I think I built a sandcastle of assumptions and I’m generating questions based off that
1
So they’ll also have the redeem script in hand and feed your inputs into it
So the whole redeem script is sent to and verified by the miners
So if that whole redeem script isn’t on chain
Is it subject to size limitations
Are there malicious scripts, say one coded to potentially crash whoever tries to verify


Hidden complexity
One of the main aim of the library is to hide the implementation complexity. It provides automatic behaviors to simplify the development and focus on useful code.
Mime Type detection
When you send an email, it is really important to indicate what is the type of the message (html, text or maybe anything else). The library automatically detects for you the Mime Type of the email content and add this information into the real sent mail for you.
Moreover, every attached file must also provide the Mime Type in order to be correctly handled by the email client. Besides, some email clients can provide a preview of attached file. This can be possible only by providing the right Mime Type. The library will detect the Mime Type for every attached file for you.
SMS
There are some implementation constraints for sending a SMS following SMPP protocol. The library will help you handle these constraints.
Phone number TON and NPI policy
SMPP defines two main properties related to the sender and recipient phone number formats: TON and NPI.
The library provides a default policy : Just pass the phone numbers and the library will guess the TON and NPI. You can also directly provide the TON and NPI in order to prevent this automatic behavior.
Character encoding
Sending SMS with the wrong charset might cause your message to be unreadable. But SMPP Charset are quite different from the common charset definition. The charset resolution is done using a simple mapping between Java charsets and SMPP charsets. By default, Java uses UTF-8 charset and the librairy will map to the SMPP charset GSM. The library offers you the ability to provide your own charset when sending SMS if need.


EFFECTIVE DATE: February 13, 2014
What information do we collect?
We collect information from you when you subscribe to our newsletter or respond to a giveaway/contest winner announcement.
What do we use your information for?
Any of the information we collect from you may be used in one of the following ways:
; To personalize your experience
(your information helps us to better respond to your individual needs)
; To improve our website
(we continually strive to improve our website offerings based on the information and feedback we receive from you)
; To improve customer service
(your information helps us to more effectively respond to your customer service requests and support needs)
; To administer a contest, promotion, survey or other site feature
; To send periodic emails
The email address you provide may be used to send you information, respond to inquiries, and/or other requests or questions.
Do we disclose any information to outside parties?
We do not sell, trade, or otherwise transfer to outside parties your personally identifiable information. This does not include trusted third parties who assist us in operating our website, conducting our business, or servicing you, so long as those parties agree to keep this information confidential. We may also release your information when we believe release is appropriate to comply with the law, enforce our site policies, or protect ours or others rights, property, or safety. However, non-personally identifiable visitor information may be provided to other parties for marketing, advertising, or other uses.
Third party links
Occasionally, at our discretion, we may include or offer third party products or services on our website. These third party sites have separate and independent privacy policies. We therefore have no responsibility or liability for the content and activities of these linked sites. Nonetheless, we seek to protect the integrity of our site and welcome any feedback about these sites.
Childrens Online Privacy Protection Act Compliance
We are in compliance with the requirements of COPPA (Childrens Online Privacy Protection Act), we do not collect any information from anyone under 13 years of age. Our website, products and services are all directed to people who are at least 13 years old or older.
Online Privacy Policy Only
This online privacy policy applies only to information collected through our website and not to information collected offline.
Your Consent
By using our site, you consent to our privacy policy.
Changes to our Privacy Policy
If we decide to change our privacy policy, we will post those changes on this page.
If you have any questions about our privacy policy email them at laurenconradeditorial@gmail.com


Feinminder admin panel
Send a text message
To: all subscribed customers
Message:
Subscribed customers
{% for subscriber in subscribers %}
{{ subscriber.phone_number }}
{% endfor %}


Overview
TextParser is a simple, extensible and lightweight library with zero dependencies, made with the aim to make process of converting text files into structured data very easy.
Perfect to work with EDI Formats like Febraban CNAB240, Febraban CNAB400, Serasa Pefin etc..


Please allow access to the schedule
To provide the best experience for your audience, allow us access to the schedule via unchecking "Keep Schedule Private" in the Scorekeeper schedule page.
Upload Awards
is your your short link
Settings
Streams
End event


7 Habits of successful people
18 Mar 2016Maintain a to-do list
Why?:
By writing down a list of things that need to be done for the next day, you increase your likelihood of achieving those goals and decrease the amount of time you waste not doing anything.
Listen to audio books
Why?:
63% of successful individuals listen to audio books during their commute instead of music.
Watch less tv
Why?:
Successful people watch very little television, one study shows that 67% of wealthy individuals watch less than an hour of tv a day. Compare that to the 78% of poor individuals that watch more than an hour of reality tv a day.
Read for self improvement
Why?:
88% percent of successful individuals read everyday to improve themselves and learn something new.
Wake up early
Why?:
Most of the top earning CEOs in the country are early risers, typically up before 6 a.m., this is the time of the day where distractions are at a minimum.
Automate tasks
Why?:
Don’t do mundane tasks when you can find a computer program to do it for you, analyse what day to day tasks you do that are repetitive. Chances are there is a piece of software that can help you do it better.
Spend wisely
Invest
Why?:
Successful people pour a larger than average percentage of their earning into pensions, retirement plans and insurance.


The main thing you should know is that we are each living in a sort of lie. "I'm just a puppet who can see the strings."
This is not real, what you are experiencing. It's real, but it's unreal.
Mind is unreal. What I mean to say is that mind presents a reality that is not consistent. Mind attempts to justify a narrative in which mind itself cannot exist. In doing so, mind attempts to ensure that it will remain sealed off from unknowns. All of this is petty immorality, impoverished. Goodness is to throw that veil off. Good is not to participate in the most petty of crimes.
When our eyes open, we see things as they are. There is no need for pettiness.
When our eyes are open, we don't see anything at all.
We see that there is Nothing, and Nothing is all it is.
"If the doors of perception were cleansed every thing would appear
to man as it is, infinite. For man has closed himself up,
till he sees all things through narrow chinks of his cavern."
The one who is awake chooses, not to participate in folly, but only to cultivate the good. That one realizes that the "self" is the "good."
and benefits ever more.


Streamline your public records requests with New Jersey’s public records request & research platform.
Presented by the Montclair University Center for Cooperative Media
August 21st, 2018
Gives you several important rights:
*exemptions apply
Generally, no matter how the request is submitted, the following steps take place:
OPRAmachine launched in October, 2017. Within its first month, its database expanded to cover all 565 municipalities in New Jersey.
OPRAmachine eliminates many of the past pains of the public records request process:
The platform also introduces several new features:
Since our launch in October, 2017:
To enable advanced features, each request is assigned a unique tracking ID
Here’s one of them: 8f40bc9f
The tracking ID is used to generate a unique email addres for each OPRA request.
Sample: opra+request-1966-8f40bc9f @requests.opramachine.com
When government agencies reply to the request, the site detects the tracking ID. This allows responses to OPRA requests to be automatically published online and with the correct request.
Since the OPRA requests are created on our site and ultimately sent via email, no proprietary softare is needed by government agencies. And paper waste is eliminated.
All you need is a valid email address to get started filing requests.
The OPRA law allows citizens to request records anonymously if they choose.
We believe OPRAmachine is the best way to file anonymous requests because user email addresses are never published or revealed to government agencies.
Only each OPRA request’s unique email is ever visible to the public or government.
OPRAmachine will notify you when your request gets a response. You’ll get an email with a link to view the response online.
An important part of the request process on OPRAmachine is classifying the status of requests. Users receive a survey when they get a response to describe the state of their OPRA request.
We ask users to classify requests so we can track outcome and trigger site functionality based on the request’s status.
Since users initially request the records, it’s easiest for them to classify their own requests
There are several states that requests can be classified into, including:
OPRAmachine lets you track requests & responses on multiple levels:
Tracking updates are sent daily via email.
A good source of leads for stories!
See what topics others are researching and view documents!
Monitor topics and geographic areas from a unified interface
Tracking alerts help keep public bodies compliant with OPRA’s time limits and reporters on deadline.
One use case we have identified is that some users will register for an account only to receive tracking updates and not to file their own requests, showing how the public records are being used by 3rd parties.
OPRAmachine has several features that make it attractive a research platform.
OPRAmachine’s advanced search tool can help you narrow down requests and documents and requests even further.
Filter content by the following criteria:
Here are some sample queries:
We are enabling comparative research using OPRA with the batch request feature.
This allows the same request to simultatenously be delivered to multiple government agencies & tracked.
Currently access to this feature is restricted to prevent abuse
Here are some succcesful batch OPRA requests:
The site has exposed more people to OPRA and public records, helping them to be better informed
By viewing requests and responses, requesters can draft better OPRA requests and know what to expect
Case study: Jeff Epstein taught citizens how to use it while researching issues in an NJ school district
The following groups of users are some examples of who is on our platform:
Running a project like this is not without its difficulties. Challenges that we have faced could be categorized as either technical or legal / moderation.
There have been multiple incidents where municipal government and police departments have inadvertently disclosed social security numbers and other confidential personal identifiers
In each instance of one of these types of disclosures, we immediately took down the material to prevent harm to individuals
Our software can automatically redact certain patterns of text.
This is currently deployed for email addresses on the site. Email addresses are automatically replaced with X’s to prevent automated spam bots from harvesting addresses from the site.
Later in 2018, we will deploy this technology for social security numbers. We hope that this will alleviate most instances of unintentional disclosures & further protect user privacy.
The more than the sum of individual OPRA requests
A fully featured OPRA toolkit for professional journalists & investigators, OPRAmachine Pro will be launching soon to sustain our development
Our core service will always remain free
Pro features:
Affordable for individuals and organizations
We are currently accepting pre-registrations from anyone interested in signing up for an OPRAmachine Pro account, with the launch of Pro services to be announced at a later date.
OPRAmachine data is open and accesible from multiple endpoints :
Data can be requested on several levels, including by:
Response by New Jersey Department of the Treasury to Gavin Rozzi on August 17, 2018.
— OPRAmachine (@OPRAmachine) August 20, 2018
Successful.
Thanks,
Department of the Treasury
Government Records Access Unit
609-633-1300
STATE OF … https://t.co/KFdev7zzX6
One other potential application of this is to automatically post all OPRA requests for a given town on a town website or Facebook page.
This example can be seen live with current data on my personal website gavinrozzi.com
The code for this is open-source on Github
Thank you for attending our webinar!
Contact the OPRAmachine team:
Email<EMAIL_ADDRESS>Phone:<PHONE_NUMBER>


An archive of CrossDoc's design deliverables and the team's presentations. The documents can be downloaded, viewed externally, and viewed in-line (by pressing the "eye" shaped button).


{% extends "userpage.html" %} {% block content %}
Before you arrive at the XDATA Experiment Dashboard you should know more about what you’ll be asked to do, and how to do it. We will walk you through some of the things you’ll need to know.
The purpose of this experiment is to determine how certain kinds of software user interfaces (analytic tools) affect analytic reasoning in the context of very large data sets—BIG data sets like social media, transportation data, and financial data, and others.
You’ll be asked to complete a number of tasks, in a specific sequence, using one of the analytic tools we’re testing. After reviewing these instructions, you’ll have access to the XDATA Experiment Dashboard. This dashboard will give you access to all tasks, in the correct order—you won’t be able to complete tasks out of order. These tasks include:
The first of your research tasks is a comprehensive intake questionnaire—this will ask you many questions regarding you expertise, education, background, as well as questions about how you approach complex analytic questions—we will even ask you to complete a few analytic problem solving questions as part of the intake. You can return to the intake at any time if you can’t complete it in one sitting, but please try to complete it.
Once you’ve completed the Intake questionnaire, you’ll have access to the XDATA Experiment Dashboard, which has a number of features:
Analytic, or “operational tasks”, will require you to make sense of the data you’re given, with the analytic tool you’re provided. Note that these tools perform best in the Google Chrome browser. You’ll be asked select questions about various entities (persons, places, things, and patterns!) within the data. Your job is to do your best to answer these questions correctly in the time allotted. You’ll start with two analytic tasks (more tasks may be available at a later date). We will give you special instructions for how to interface with these tasks and the software you will use to complete them.
Following each of the two analytic tasks, you’ll be diverted to a short post-task survey that will ask about you about your experiences in the previous task.
Following your second analytic task and post-task, you’ll tracked in to a comments form that will allow you to tell us about your experience in your own words. Once submitted these comments will be immediately visible to the developers that built the application you used—help us make these applications better by providing constructive comments about your experience!
Once you have completed your tasks, you will have the option to keep participating. If you are completing this study as a Mechanical Turk Worker, you will be provided a survey completion code at this time.


0 Farmers reached
Agrishot provides a helping technology to the farmers with services like transport pooling, farming techniques, establish relationship among fellow farmers and also provide them the know-how of taking help from the website.
0 Farmers reached
"As the Republican platforms says, the welfare of the farmer is vital to that of the whole country."
— William Howard Taft
"Fresh vegetables and fruits are the birth right of every citizen."
"Pollution can be reduced if citizens start working at indidual levels by reducing the number of vehicles on the road."
In case of any technical help feel free to contact :
JC BOSE University Of Science And Technology, YMCA, Faridabad
Agrishot is the hardwork of a huge number of industries and people thet provided their support and investments.
Agrishot aims at providing ease to the most important occupation of the world.
Rohit Sehwag
CEO Founder of AgrishotProviding Agrishot an interface with the skills that I have got makes me feel proud.
Shivam Mehla
CEO of Web DevelopersAgrishot aims at providing ease to the most important occupation of the world.
Sahil Jindal
Exterior DesignerAgrishot aims at providing ease to the most important occupation of the world.
Dinesh Singh
Landscape DesignerAgrishot aims at providing ease to the most important occupation of the world.
Ritik Chauhan
System Analyst


| Candidate | Type | Submissions |
|---|---|---|
| Shanshan | Person | 10.000 |
| Alessandro | Person | 8.000 |
| Mondeca | Organization | 1.000 |
| Paris | Location | 500 |
| Paris 10 | Quarter | 200 |
| Favorite topics | Type | |
|---|---|---|
| Shanshan | Person | |
| Alessandro | Person | |
| Mondeca | Organization | |
| Paris | Location | |
| Paris 10 | Quarter |
| Type | Instances | % |
|---|---|---|
| Teacher | 10.000 | 50% |
| City | 8.000 | 40% |
| University | 1.000 | 10% |
| Athlete | 800 | 8% |
| Garden | 200 | 2% |


The Greatest of All Time
JUSTIN DREW BIEBER!!
"200" "215"
Bio
Justin Drew Bieber, is a Canadian singer, songwriter and multi-instrumentalist.
Discovered at age 13 by talent manager Scooter Braun after he had watched Bieber's
YouTube cover song videos, Bieber was signed to RBMG Records in 2008. With Bieber's
debut EP My World, released in late 2009, Bieber became the first artist to have
seven songs from a debut record chart on the
Billboard Hot 100.
For Your Own Information
Singer Songwriter Musician
Years Active 2007-present
Spouse(s) Hailey Baldwin (m. 2018)
Justins Website
This is a link
link To New Music By Justin Bieber


Employee Directory
Click on the name to filter A-Z or Z-A!!!
Image
Name
Phone
Email
D.O.B.
Johnny Bravo
(562) 250-8932
<EMAIL_ADDRESS>11/30/2020


Hi! I'm Roman Bernardo, and you've reached my webpage! I graduated in 2012 with a B.A. in mathematics. I am an aspiring web developer, hoping to make waves one day.
I'm currently working as an internet analyst for Rater Labs!
Competencies:
- HTML
- CSS
- Python
- C
Interests:
- Drawing
- Playing piano/guitar/singing
- Veganism
- Being happy
Roman's Portfolio
My portfolio will be filled as I progress through Free Code Camp. Stay tuned!


Change your {{data['page']}}
Contact<EMAIL_ADDRESS>to make changes to your:
- registered company name
- registration number
- VAT number
- DUNS number
Return to company details
Contact<EMAIL_ADDRESS>to make changes to your:


{{title}}
{{title}}
{{title}}
PAYMENT TERMS AND POLICIES All accounts are to be paid within 7 day. To be paid by cheque or credit card or direct payment online. If account is not paid within 7 days the credits details supplied as confirmation of work undertaken will be charged the agreed quoted fee noted above. If the Invoice remails unpaid.


{{selectedShow.description}}
Categories:
{{selectedShow.genre.category}} ,
{{selectedShow.genre.name}}
Introduction
Similar Reading
If you liked this book, we would recommend you check out these emerging titles
{{recommendedItem.name}}
By {{recommendedItem.author.name}}


Email
Email is one of the most popular client/server applications on the Internet. Email servers run server software that enables them to interact with clients and with other email servers over the network.
Each mail server receives and stores mail for users who have mailboxes configured on the mail server. Each user with a mailbox must then use an email client to access the mail server and read these messages.
Mail servers are also used to send mail addressed to local mailboxes or mailboxes located on other email servers.
Mailboxes are identified by the format:
<EMAIL_ADDRESS>Various application protocols used in processing email include SMTP, POP3, IMAP4.
Telnet
Telnet is a protocol which makes the connection between two remote computers (called hosts) possible over a TCP/IP network ( such as Internet). It can be used to connect host (client PC) with the server on the network. Once your telnet client establishes a connection to the remote host (or server), the client becomes a virtual terminal, allowing us to communicate with the remote host from client computer. The commands entered at client side using telnet are directly executed on the server console. In this way server can be controlled from client side.
Telnet clients are available for all major operating systems.
Command-line telnet clients are built into most OS and it can be activated from command prompt by entering command :
telnet [host-name] or
telnet [IP-address]
Replace host with the name or IP address of the remote computer to which you wish to connect.
Hence telnet is a network protocol used on LAN, WAN or Internet to provide bidirectional interactive communication facility.
File Transfer Program(FTP)
FTP is the user interface to the Internet standard File Transfer Protocol. The program allows a user to transfer files to and from a remote network site. Options may be specified at the command line or to the command interpreter.
The FTP service lets you transfer files from one connected computer to another. However there is one basic restriction you cannot access a computer unless you log on to it. In other words you cannot copy files to or from a remote computer unless you have a valid username and a password.
Anonymous FTP is a facility that lets you connect to certain hosts and download files without having to be a registered user. To do so, you log in using a special user name - anonymous. With this user name you do not need a regular password. Instead you type your mail address. Some files in the FTP servers may be accessible to the general public, while others are accessible only by the user. To separate the general public from the registered users, FTP servers are divided into two parts:
- Anonymous server
- Non-anonymous server
Search Engine
A Search Engine is a program that can search a large database for specific information. On the web, there are a number of search engines devoted to keep track of everything on the web, and you can use them for free(The companies that maintain them make their money by selling advertisement slots).
Some of popular search engines are:
1. Yahoo! And Alta Vista
2. HotBot
3. WebCrawler
4. Excite
5. Lycos
6. Magellan
7. Google
Each search engine is different and you must learn to use it in its own way. For Example, Yahoo and AltaVista keep track of a great deal of the content on the web but they do so in completely different ways.
The Yahoo search engine seeks to categorize everything on the web. When you use Yahoo to search for something, the results are given as a list of categories related to that something. If you select a category, you will be shown links to Web pages falling in that category.
The AltaVista search engine has a different emphasis. AltaVista does its best to maintain copy of all the information on the web. You use AltaVista to look for specific words and it responds by showing you a list of links to web pages that contain those words.


Static Member Summary
| Static Private Members | ||
| private static |
A map of the installed plugins. |
Static Method Summary
| Static Public Methods | ||
| public static |
use(Plugin: Function, args: Object): Promise<PopApiScraper> Register middleware for the PopApi framework. |
Constructor Summary
| Public Constructor | ||
| public |
constructor(PopApi: PopApi, options: Object) Create a new BaseScraper object. |
Member Summary
| Public Members | ||
| public |
The context to execute the providers in. |
|
| public |
The path of the status file. |
|
| public |
The path of the updated file. |
Method Summary
| Public Methods | ||
| public |
Get the status object. |
|
| public |
getUpdated(): Promise<number, Error> Get the updated object. |
|
| public |
Initiate the scraping. |
|
| public |
Updates the |
|
| public |
setUpdated(updated: number): Promise<undefined, Error> Updates the |
Static Public Methods
public static use(Plugin: Function, args: Object): Promise<PopApiScraper> source
Register middleware for the PopApi framework.
Public Constructors
public constructor(PopApi: PopApi, options: Object) source
Create a new BaseScraper object. The base modules for popcorn-api
Params:
| Name | Type | Attribute | Description |
| PopApi | PopApi |
|
The PopApiScraper instance. |
| options | Object |
|
The options for the BaseScraper middleware. |
| options.statusPath | string |
|
= - The path of the status file. |
| options.updatedPath | string |
|
The path of the updated file. |
Public Members
Public Methods
public async scrape(concurrency: number): Promise<Array<Object>, Error> source
Initiate the scraping.
Params:
| Name | Type | Attribute | Description |
| concurrency | number |
|
How many providers to scrape concurrently. |
public setStatus(status: string): Promise<undefined, Error> source
Updates the status.json
file.
Params:
| Name | Type | Attribute | Description |
| status | string |
|
The status which will be set to in the
|


C++ Support in Clang
Last updated: $Date: 2010-02-09 10:50:54 -0600 (Tue, 09 Feb 2010) $
Clang C++ Status
Clang currently implements nearly all of the ISO C++ 1998 standard (including the defects addressed in the ISO C++ 2003 standard), with the few notable exceptions listed below. However, the implementation of Clang C++ is still quite immature, with many remaining bugs that are likely to cause compiler crashes, erroneous errors and warnings, and miscompiled code. The LLVM bug tracker contains a Clang C++ component that tracks known Clang C++ bugs.
Clang is currently missing implementations of the following C++98/03 features and common extensions:
- Access control: Clang does not perform access-control checking at this time, so it will fail to diagnose invalid accesses. Work is underway to implement this feature.
- Friends and friend templates: Clang parses friends and friend templates for the most part, but they are not used in access control and there are a number of problems with friend templates and friends within class templates.
- GNU strong using extension.
- Qualified member accesses that disambiguate the base class in a diamond-shaped inheritance hierarchy.
Projects Building with Clang
Clang is now capable of compiling some language C++ projects, or large pieces of such projects. The following table describes various projects that we have attempted to compile with Clang along with the results of that attempt.
At this point in time, each new C++ project typically uncovers new bugs. We keep track of these in the LLVM bug tracker via tracking bugs, which are used to relate all of the bugs known to affect that particular project. Introducing a new project in this list typically requires a liason familiar with LLVM or Clang development, who is able to provide detailed bug reports and track progress for the particular project.
| Project | Status | Last Tested | Tracking Bug |
|---|---|---|---|
| Clang and LLVM | Successful self-hosting achieved | Continually | |
| CMake | Compiles, passes regression tests (debug build) | February 9, 2010 | |
| Qt | Partially compiles; miscompilation of uic prevents complete compilation, qmake works, some small examples also. | February 9, 2010 | PR5881 |
| Boost | Some libraries (e.g., Boost.MPL) successfully build and pass regression tests, the majority still fail. | February 5, 2010 | PR6023 |
Implementation Status by Section
The following table is used to help track our implementation progress toward implementing the complete C++03 standard. We use a simple, somewhat arbitrary color-coding scheme to describe the relative completeness of features by section:
| Not started/not evaluated | Not Applicable | Broken | Some examples work | Many examples work | Nearly everything works | Complete | Complete (with tests for each paragraph) |
|---|---|---|---|---|---|---|---|
| N/A | ✓ |
A feature is "complete" when the appropriate Clang component (Parse, AST, Sema, CodeGen) implements the behavior described in all of the paragraphs in the relevant C++ standard. Note that many C++ features are actually described in several different sections within the standard. The major components are:
- Parse
- Clang is able to parse the grammar of this feature (or the grammar described by this section), but does not necessarily do anything with the parsed result. Use Clang's
-fsyntax-only
option to parse C++ programs. - AST
- Clang builds an abstract syntax tree (AST) for the feature, but does not necessarily perform any type-checking. Use Clang's
-ast-print
option to print the resulting ASTs. - Sema
- Clang parses and type-checks this feature and provides a well-formed AST annotated with types. Use Clang's
-fsyntax-only
to type-check code. - CodeGen
- Clang parses, type-checks, and generates code for this feature, allowing one to compile and execute programs.
Updates to this table are welcome! Since Clang already supports much of C, and therefore much C++, many of the currently-white cells could be filled in. If you wish to do so, please compare Clang's implementation against the C++ standard and provide a patch that updates the table accordingly. Tests for the various features are also welcome!
| Section | Parse | AST | Sema | CodeGen | Notes |
|---|---|---|---|---|---|
| 2 [lex] | N/A | N/A | N/A | ||
| 2.1 [lex.phases] | N/A | N/A | N/A | Extended characters aren't handled. | |
| 2.2 [lex.charset] | N/A | N/A | N/A | No support for extended characters. | |
| 2.3 [lex.trigraph] | N/A | N/A | N/A | ||
| 2.4 [lex.pptoken] | N/A | N/A | N/A | ||
| 2.5 [lex.digraph] | N/A | N/A | N/A | ||
| 2.6 [lex.token] | N/A | N/A | N/A | ||
| 2.7 [lex.comment] | N/A | N/A | NDR "form feed or vtab in comment" is not diagnosed. | ||
| 2.8 [lex.header] | N/A | N/A | N/A | ||
| 2.9 [lex.ppnumber] | N/A | N/A | N/A | ||
| 2.10 [lex.name] | N/A | N/A | N/A | No support for extended characters | |
| 2.11 [lex.key] | N/A | N/A | N/A | ||
| 2.12 [lex.operators] | N/A | N/A | N/A | ||
| 2.13 [lex.literal] | N/A | N/A | N/A | ||
| 2.13.1 [lex.icon] | N/A | N/A | N/A | ||
| 2.13.2 [lex.ccon] | N/A | N/A | N/A | Poor support for extended characters | |
| 2.13.3 [lex.fcon] | N/A | N/A | N/A | ||
| 2.13.4 [lex.string] | N/A | N/A | N/A | Poor support for extended characters | |
| 2.13.5 [lex.bool] | N/A | N/A | N/A | ||
| 3 [basic] | N/A | N/A | N/A | N/A | |
| 3.1 [basic.def] | N/A | ||||
| 3.2 [basic.def.odr] | |||||
| 3.3 [basic.scope] | N/A | N/A | N/A | ||
| 3.3.1 [basic.scope.pdecl] | N/A | N/A | N/A | ||
| 3.3.2 [basic.scope.local] | N/A | N/A | N/A | ||
| 3.3.3 [basic.scope.proto] | N/A | N/A | N/A | ||
| 3.3.4 [basic.funscope] | N/A | N/A | N/A | ||
| 3.3.5 [basic.scope.namespace] | N/A | N/A | N/A | ||
| 3.3.6 [basic.scope.class] | N/A | N/A | N/A | Does not check that reordering the members of a class maintains semantics. | |
| 3.3.7 [basic.scope.hiding] | N/A | N/A | N/A | ||
| 3.4 [basic.lookup] | N/A | N/A | N/A | ||
| 3.4.1 [basic.lookup.unqual] | N/A | N/A | N/A | ||
| 3.4.2 [basic.lookup.argdep] | N/A | N/A | N/A | ||
| 3.4.3 [basic.lookup.qual] | N/A | N/A | N/A | ||
| <IP_ADDRESS> [class.qual] | N/A | N/A | N/A | ||
| <IP_ADDRESS> [namespace.qual] | N/A | N/A | N/A | ||
| 3.4.4 [basic.lookup.elab] | |||||
| 3.4.5 [basic.lookup.classref] | N/A | N/A | N/A | Missing ambiguity/consistency checks for paragraphs 3 (~type-name) and 7 (conversion-type-id) | |
| 3.4.6 [basic.lookup.udir] | N/A | N/A | N/A | ||
| 3.5 [basic.link] | |||||
| 3.6 [basic.start] | |||||
| 3.6.1 [basic.start.main] | |||||
| 3.6.2 [basic.start.init] | |||||
| 3.6.3 [basic.start.term] | |||||
| 3.7 [basic.stc] | |||||
| 3.7.1 [basic.stc.static] | |||||
| 3.7.2 [basic.stc.auto] | |||||
| 3.7.3 [basic.stc.dynamic] | |||||
| <IP_ADDRESS> [basic.stc.dynamic.allocation] | |||||
| <IP_ADDRESS> [basic.stc.dynamic.deallocation] | |||||
| 3.7.4 [basic.stc.inherit] | |||||
| 3.8 [basic.life] | |||||
| 3.9 [basic.types] | |||||
| 3.9.1 [basic.fundamental] | |||||
| 3.9.2 [basic.compound] | |||||
| 3.9.3 [basic.type.qualifier] | |||||
| 3.10 [basic.lval] | |||||
| 4 [conv] | |||||
| 4.1 [conv.lval] | |||||
| 4.2 [conv.array] | |||||
| 4.3 [conv.func] | |||||
| 4.4 [conv.qual] | |||||
| 4.5 [conv.prom] | |||||
| 4.6 [conv.fpprom] | |||||
| 4.7 [conv.integral] | |||||
| 4.8 [conv.double] | |||||
| 4.9 [conv.fpint] | |||||
| 4.10 [conv.ptr] | |||||
| 4.11 [conv.mem] | |||||
| 4.12 [conv.bool] | |||||
| 5 [expr] | N/A | N/A | ✓ | N/A | |
| 5.1 [expr.prim] | |||||
| 5.2 [expr.post] | |||||
| 5.2.1 [expr.sub] | |||||
| 5.2.2 [expr.call] | |||||
| 5.2.3 [expr.type.conv] | |||||
| 5.2.4 [expr.pseudo] | |||||
| 5.2.5 [expr.ref] | |||||
| 5.2.6 [expr.post.incr] | |||||
| 5.2.7 [expr.dynamic.cast] | |||||
| 5.2.8 [expr.typeid] | |||||
| 5.2.9 [expr.static.cast] | |||||
| 5.2.10 [expr.reinterpret.cast] | |||||
| 5.2.11 [expr.const.cast] | |||||
| 5.3 [expr.unary] | |||||
| 5.3.1 [expr.unary.op] | |||||
| 5.3.1p1 Unary * | |||||
| 5.3.1p2-5 Unary & | |||||
| 5.3.1p6 Unary + | |||||
| 5.3.1p7 Unary - | |||||
| 5.3.1p8 Unary ! | |||||
| 5.3.1p9 Unary ~ | |||||
| 5.3.2 [expr.pre.incr] | |||||
| 5.3.3 [expr.sizeof] | |||||
| 5.3.4 [expr.new] | operator delete is not looked up, initialization not quite correct | ||||
| 5.3.5 [expr.delete] | |||||
| 5.4 [expr.cast] | |||||
| 5.5 [expr.mptr.oper] | Dereferenced member function pointers have the wrong type(see FIXME in CheckPointerToMemberOperands). | ||||
| 5.6 [expr.mul] | |||||
| 5.7 [expr.add] | |||||
| 5.8 [expr.shift] | |||||
| 5.9 [expr.rel] | |||||
| 5.10 [expr.eq] | |||||
| 5.11 [expr.bit.and] | |||||
| 5.12 [expr.xor] | |||||
| 5.13 [expr.or] | |||||
| 5.14 [expr.log.and] | |||||
| 5.15 [expr.log.or] | |||||
| 5.16 [expr.cond] | some invalid hierarchy casts still accepted, but that's a general problem | ||||
| 5.17 [expr.ass] | |||||
| 5.18 [expr.comma] | |||||
| 5.19 [expr.const] | Uses C semantics | ||||
| 6 [stmt.stmt] | |||||
| 6.1 [stmt.label] | |||||
| 6.2 [stmt.expr] | |||||
| 6.3 [stmt.block] | |||||
| 6.4 [stmt.select] | Conversion of declarations to required types not really supported. | ||||
| 6.4.1 [stmt.if] | |||||
| 6.4.2 [stmt.switch] | |||||
| 6.5 [stmt.iter] | Conversion of declarations to required types not really supported. | ||||
| 6.5.1 [stmt.while] | |||||
| 6.5.2 [stmt.do] | |||||
| 6.5.3 [stmt.for] | |||||
| 6.6 [stmt.jump] | |||||
| 6.6.1 [stmt.break] | |||||
| 6.6.2 [stmt.cont] | |||||
| 6.6.3 [stmt.return] | |||||
| 6.6.4 [stmt.goto] | |||||
| 6.7 [stmt.dcl] | Existence and accessibility of destructors is not tested for. | ||||
| 6.8 [stmt.ambig] | |||||
| 7 [dcl.dcl] | |||||
| 7.1 [dcl.spec] | |||||
| 7.1.1 [dcl.stc] | Linkage merging has some errors. | ||||
| 7.1.2 [dcl.fct.spec] | |||||
| 7.1.3 [dcl.typedef] | |||||
| 7.1.4 [dcl.friend] | |||||
| 7.1.5 [dcl.type] | |||||
| <IP_ADDRESS> [dcl.type.cv] | |||||
| <IP_ADDRESS> [dcl.type.simple] | |||||
| <IP_ADDRESS> [dcl.type.elab] | |||||
| 7.2 [dcl.enum] | |||||
| 7.3 [basic.namespace] | |||||
| 7.3.1 [namespace.def] | |||||
| <IP_ADDRESS> [namespace.unnamed] | |||||
| <IP_ADDRESS> [namespace.memdef] | |||||
| 7.3.2 [namespace.alias] | N/A | ||||
| 7.3.3 [namespace.udecl] | N/A | ||||
| 7.3.4[namespace.udir] | Example in p4 fails. | ||||
| 7.4 [dcl.asm] | |||||
| 7.5 [dcl.link] | |||||
| 8 [dcl.decl] | |||||
| 8.1 [dcl.name] | N/A | ||||
| 8.2 [dcl.ambig.res] | ✓ | N/A | ✓ | N/A | |
| 8.3 [dcl.meaning] | N/A | ||||
| 8.3.1 [dcl.ptr] | N/A | ||||
| 8.3.2 [dcl.ref] | N/A | ||||
| 8.3.3 [dcl.mptr] | N/A | ||||
| 8.3.4 [dcl.array] | N/A | ||||
| 8.3.5 [dcl.fct] | N/A | ||||
| 8.3.6 [dcl.fct.default] | N/A | Partial support for default arguments of templates. | |||
| 8.4 [dcl.fct.def] | |||||
| 8.5 [dcl.init] | |||||
| 8.5.1[dcl.init.aggr] | No CodeGen for dynamic initialization. | ||||
| 8.5.2[dcl.init.string] | |||||
| 8.5.3 [dcl.init.ref] | |||||
| 9 [class] | |||||
| 9.1 [class.name] | N/A | ||||
| 9.2 [class.mem] | |||||
| 9.3 [class.mfct] | |||||
| 9.3.1 [class.mfct.non-static] | |||||
| 9.3.2 [class.this] | |||||
| 9.4 [class.static] | |||||
| 9.4.1 [class.static.mfct] | |||||
| 9.4.2 [class.static.data] | |||||
| 9.5 [class.union] | |||||
| 9.6 [class.bit] | |||||
| 9.7 [class.nest] | N/A | ||||
| 9.8 [class.local] | ✓ | ✓ | ✓ | N/A | |
| 9.9 [class.nested.type] | ✓ | ✓ | ✓ | N/A | |
| 10 [class.derived] | |||||
| 10.1 [class.mi] | |||||
| 10.2 [class.member.lookup] | N/A | ||||
| 10.3 [class.virtual] | |||||
| 10.4 [class.abstract] | N/A | ||||
| 11 [class.access] | N/A | ||||
| 11.1 [class.access.spec] | N/A | ||||
| 11.2 [class.access.base] | N/A | ||||
| 11.3 [class.access.dcl] | N/A | ||||
| 11.4 [class.friend] | N/A | ||||
| 11.5 [class.protected] | N/A | ||||
| 11.6 [class.access.virt] | N/A | ||||
| 11.7 [class.paths] | N/A | ||||
| 11.8 [class.access.nest] | N/A | ||||
| 12 [special] | |||||
| 12.1 [class.ctor] | |||||
| 12.2 [class.temporary] | N/A | ||||
| 12.3 [class.conv] | |||||
| 12.3.1 [class.conv.ctor] | |||||
| 12.3.2 [class.conv.fct] | |||||
| 12.4 [class.dtor] | |||||
| 12.5 [class.free] | |||||
| 12.6 [class.init] | |||||
| 12.6.1 [class.expl.init] | |||||
| 12.6.2 [class.base.init] | Most of the semantics of base initializations are implemented. | ||||
| 12.7 [class.cdtor] | |||||
| 12.8 [class.copy] | Most of the semantics of copy constructors are implemented. | ||||
| 13 [over] | |||||
| 13.1 [over.load] | N/A | ||||
| 13.2 [over.dcl] | N/A | N/A | |||
| 13.3 [over.match] | N/A | N/A | |||
| 13.3.1 [over.match.funcs] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.call] | N/A | N/A | |||
| <IP_ADDRESS>.1 [over.call.func] | N/A | N/A | |||
| <IP_ADDRESS>.2 [over.call.object] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.oper] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.ctor] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.copy] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.conv] | N/A | N/A | |||
| <IP_ADDRESS> [over.match.ref] | N/A | N/A | |||
| 13.3.2 [over.match.viable] | N/A | N/A | |||
| 13.3.3 [over.match.best] | N/A | N/A | |||
| <IP_ADDRESS> [over.best.ics] | N/A | N/A | |||
| <IP_ADDRESS>.1 [over.ics.scs] | N/A | N/A | |||
| <IP_ADDRESS>.2 [over.ics.user] | N/A | N/A | |||
| <IP_ADDRESS>.3 [over.ics.ellipsis] | N/A | N/A | |||
| <IP_ADDRESS>.4 [over.ics.ref] | N/A | N/A | |||
| <IP_ADDRESS> [over.ics.rank] | N/A | N/A | |||
| 13.4 [over.over] | N/A | N/A | |||
| 13.5 [over.oper] | N/A | ||||
| 13.5.1 [over.unary] | N/A | N/A | |||
| 13.5.2 [over.binary] | N/A | N/A | |||
| 13.5.3 [over.ass] | N/A | N/A | |||
| 13.5.4 [over.call] | N/A | N/A | |||
| 13.5.5 [over.sub] | N/A | N/A | |||
| 13.5.6 [over.ref] | N/A | N/A | |||
| 13.5.7 [over.inc] | N/A | N/A | |||
| 13.6 [over.built] | N/A | N/A | Missing support for the ternary operator (p24, p25). | ||
| 14 [temp] | |||||
| 14.1 [temp.param] | ✓ | ✓ | N/A | ||
| 14.2 [temp.names] | N/A | ||||
| 14.3 [temp.arg] | N/A | ||||
| 14.3.1 [temp.arg.type] | ✓ | ✓ | N/A | Paragraph 3 will be tested elsewhere | |
| 14.3.2 [temp.arg.nontype] | N/A | ||||
| 14.3.3 [temp.arg.template] | N/A | ||||
| 14.4 [temp.type] | N/A | ✓ | ✓ | N/A | |
| 14.5 [temp.decls] | |||||
| 14.5.1 [temp.class] | |||||
| <IP_ADDRESS> [temp.mem.func] | |||||
| <IP_ADDRESS> [temp.mem.class] | |||||
| <IP_ADDRESS> [temp.static] | |||||
| 14.5.2 [temp.mem] | |||||
| 14.5.3 [temp.friend] | N/A | ||||
| 14.5.4 [temp.class.spec] | N/A | ||||
| <IP_ADDRESS> [temp.class.spec.match] | N/A | N/A | N/A | ||
| <IP_ADDRESS> [temp.class.order] | N/A | ||||
| <IP_ADDRESS> [temp.class.spec.mfunc] | N/A | ||||
| 14.5.5 [temp.fct] | |||||
| <IP_ADDRESS> [temp.over.link] | N/A | ||||
| <IP_ADDRESS> [temp.func.order] | N/A | ||||
| 14.6 [temp.res] | |||||
| 14.6.1 [temp.local] | |||||
| 14.6.2 [temp.dep] | N/A | ||||
| <IP_ADDRESS> [temp.dep.type] | N/A | ||||
| <IP_ADDRESS> [temp.dep.expr] | N/A | ||||
| <IP_ADDRESS> [temp.dep.constexpr] | N/A | ||||
| <IP_ADDRESS> [temp.dep.temp] | N/A | ||||
| 14.6.3 [temp.nondep] | N/A | ||||
| 14.6.4 [temp.dep.res] | N/A | ||||
| <IP_ADDRESS> [temp.point] | N/A | ||||
| <IP_ADDRESS> [temp.dep.candidate] | N/A | Not restricted to functions with external linkage | |||
| 14.6.5 [temp.inject] | N/A | ||||
| 14.7 [temp.spec] | |||||
| 14.7.1 [temp.inst] | N/A | ||||
| 14.7.2 [temp.explicit] | Cannot test paragraph 11 until access control is implemented. ASTs do not carry enough information to reproduce source code accurately. |
||||
| 14.7.3 [temp.expl.spec] | ✓ | ✓ | ASTs do not carry enough information to reproduce source code accurately | ||
| 14.8 [temp.fct.spec] | |||||
| 14.8.1 [temp.arg.explicit] | |||||
| 14.8.2 [temp.deduct] | N/A | N/A | N/A | ||
| <IP_ADDRESS> [temp.deduct.call] | |||||
| <IP_ADDRESS> [temp.deduct.funcaddr] | N/A | N/A | |||
| <IP_ADDRESS> [temp.deduct.conv] | |||||
| <IP_ADDRESS> [temp.deduct.type] | N/A | N/A | |||
| 14.8.3 [temp.over] | |||||
| 15 [except] | |||||
| 15.1 [except.throw] | N/A | N/A | |||
| 15.2 [except.ctor] | N/A | N/A | N/A | ||
| 15.3 [except.handle] | N/A | N/A | Not all constraints are checked | ||
| 15.4 [except.spec] | |||||
| 15.5 [except.special] | N/A | N/A | N/A | N/A | |
| 15.5.1 [except.terminate] | N/A | N/A | N/A | N/A | |
| 15.5.2 [except.unexpected] | N/A | N/A | N/A | N/A | |
| 15.5.3 [except.uncaught] | N/A | N/A | N/A | N/A | |
| 15.6 [except.access] | N/A | N/A | N/A | N/A | Redundant - struck from C++0x |
| 16 [cpp] | |||||
| 16.1 [cpp.cond] | |||||
| 16.2 [cpp.include] | |||||
| 16.3 [cpp.replace] | |||||
| 16.3.1 [cpp.subst] | |||||
| 16.3.2 [cpp.stringize] | |||||
| 16.3.3 [cpp.concat] | |||||
| 16.3.4 [cpp.rescan] | |||||
| 16.3.5 [cpp.scope] | |||||
| 16.4 [cpp.line] | |||||
| 16.5 [cpp.error] | |||||
| 16.6 [cpp.pragma] | |||||
| 16.7 [cpp.null] | |||||
| 16.8 [cpp.predefined] | |||||
| A [gram] | |||||
| A.1 [gram.key] | |||||
| A.2 [gram.lex] | |||||
| A.3 [gram.basic] | |||||
| A.4 [gram.expr] | |||||
| A.5 [gram.stmt] | |||||
| A.6 [gram.dcl] | |||||
| A.7 [gram.decl] | |||||
| A.8 [gram.class] | |||||
| A.9 [gram.derived] | |||||
| A.10 [gram.special] | |||||
| A.11 [gram.over] | |||||
| A.12 [gram.temp] | |||||
| A.13 [gram.except] | |||||
| A.14 [gram.cpp] | |||||
| B [implimits] | |||||
| C [diff] | |||||
| C.1 [diff.iso] | |||||
| C.1.1 [diff.lex] | |||||
| C.1.2 [diff.basic] | |||||
| C.1.3 [diff.expr] | |||||
| C.1.4 [diff.stat] | |||||
| C.1.5 [diff.dcl] | |||||
| C.1.6 [diff.decl] | |||||
| C.1.7 [diff.class] | |||||
| C.1.8 [diff.special] | |||||
| C.1.9 [diff.cpp] | |||||
| C.2 [diff.library] | |||||
| C.2.1 [diff.mods.to.headers] | |||||
| C.2.2 [diff.mods.to.definitions] | |||||
| C.2.2.2 [diff.wchar.t] | |||||
| C.2.2.3 [diff.header.iso646.h] | |||||
| C.2.2.4 [diff.null] | |||||
| C.2.3 [diff.mods.to.declarations] | |||||
| C.2.4 [diff.mods.to.behavior] | |||||
| C.2.4.1 [diff.offsetof] | |||||
| C.2.4.2 [diff.malloc] | |||||
| D [depr] | |||||
| D.1 [depr.incr.bool] | |||||
| D.2 [depr.static] | |||||
| D.3 [depr.access.dcl] | |||||
| D.4 [depr.string] | |||||
| D.5 [depr.c.headers] | |||||
| E [extendid] | |||||
C++0x Implementation status
Clang's development effort is focused primarily on supporting the current ISO C++ standard (1998/2003). This section tracks the status of various C++0x features. In general, the implementations of these features are far less developed than C++98/03 features.
| C++0x Features | |||||
| Explicit conversion operators (N2437) | No name mangling; ASTs don't contain calls to conversion operators | ||||
| Static assertions (N1720) | N/A | ||||
| Deleted functions (N2346) | N/A | ||||
| Rvalue references (N2118 + N2831) | |||||
| nullptr (N2431) | |||||
| Right angle brackets (N1757) | N/A | N/A | N/A | ||
| Decltype (N2343) | ✓ | ✓ | ✓ | N/A |


Basic operations with data
Data engine, data scope and repository
To start using XData You need get IDataEngine interface reference (see examples below). It will be used to create new data scopes using NewDataScope method.
XData use data scope isolation when same typed repositories used by multiple logic at the same time. Data scope is represented by IDataScope interface. Data scope identified by Layer (GUID).
Important
IDataScope is IDisposable. When disposing IDataScope all repositories, opened at this scope are disposed and XData free all memory used by this data scope.
To get data object instances of type T it's required to get typed repository interface IRepository<T> using method GetRepository<T> of IDataScope.
Tip
IRepository is also IDisposable. When disposing IRepository it's data cache cleared. You can dispose repositories manually, but if not, disposing data scope will free that repository resources. Recommended to dispose large data repositories manually to reduce memory utilized by application.
While repository is not disposed inside data scope it can be requested many times without recreating and database access and GetRepository<T> method of same IDataScope returns the same instance of repository.
Net 4.0:
using (var dataEngine = XDataManager.InitXData(x =>
x.UseConfiguration(ConfigurationManager
.OpenExeConfiguration(ConfigurationUserLevel.None))))
{
using (var dataScope = dataEngine.NewDataScope())
{
foreach(var data in dataScope.GetRepository<SomeObject>())
Console.WriteLine(string.Format("{0}, {1}", data.SomeId, data.Name));
}
}
NetStandard 2.0:
//Set configuration file
var builder = new ConfigurationBuilder();
builder.AddXmlFile("MyConsoleApp.config");
var configFile = builder.Build();
//Set services
using(var serviceProvider = new ServiceCollection()
.AddLogging()
// Localization only for ASP.NET Core
.AddSingleton(typeof(IStringLocalizerFactory), x => null)
.AddSingleton(typeof(IConfigurationRoot), x => configFile)
.AddXData()
.BuildServiceProvider())
{
//Configure logging (logger messages minimal allowed levels can be set using config file)
serviceProvider.GetRequiredService<ILoggerFactory>()
.AddConsole(LogLevel.Warning).AddDebug(LogLevel.Debug);
var dataEngine = serviceProvider.GetRequiredService<IDataEngine>();
using (var dataScope = dataEngine.NewDataScope())
{
foreach(var data in dataScope.GetRepository<SomeObject>())
Console.WriteLine($"{data.SomeId}, {data.Name}");
}
}
Data object properties access
Read/write properties using has no specifics:
var invoice = dataScope.GetRepository<Invoice>().First();
invoice.DocNumb = "12345";
Except Link, Lob and Xml discussed below.
Changing data
It's possible to change data object properties with assignment operator (except Link, Lob and Xml discussed below):
var newInvoice = dataScope.GetRepository<Invoice>().New();
newInvoice.DocNumb = String.Format("Inv-{0}", number.ToString(CultureInfo.InvariantCulture).PadLeft(6, '0'));
newInvoice.Submit();
To edit data of new object You can also use New method overload with initialization logic wrapper:
return dataScope.GetRepository<Invoice>().New(
//property DocNumb is a sting assigned as usual
z => z.DocNumb = String.Format("Inv-{0}",
number.ToString(CultureInfo.InvariantCulture).PadLeft(6, '0')),
//property DocCatalog - link to data object typed Catalog
//assignment using += operator is the same as DocCatalog.Source = ...
z => z.DocCatalog +=
dataScope.GetDictionaryValue<Catalog>(x => x.Code == catalogCode),
//property DeliveryType is enum DeliveryTypeEnum
z => z.DeliveryType = DeliveryTypeEnum.PickUp,
//property DeliveryDate is DateTime
z => z.DeliveryDate = DateTime.Today.AddDays(1),
//property Source is Xml, assignment using += operator is the same as
//Source.Document = ...
z => z.Source += new XDocument(
new XElement("invoice",
new XAttribute("number", number),
new XAttribute("state", z.DocStateCode))),
//property Source - is a large binary object (Lob) and assignment using += operator
//is the same as Scan.Value = ...
z => z.Scan += Encoding.UTF8.GetBytes(z.Source.Document.ToString
).Submit(out _);
Or Modify method extension to change object data:
var invoice = dataScope.GetRepository<Invoice>()
.SingleOrDefault(x => x.DocNumb.Like($"%0{number}") && x.DocStateCode == oldStateCode);
if (invoice == null) return true;
return invoice.Modify(
z => z.DocState += dataScope.GetDictionaryValue<DocState>(x => x.Code == newStateCode),
z => z.Source.Modify(doc => doc.Element("invoice").Attribute("state").Value = newStateCode))
.Submit(out _);
Delete
XData has ability to mark data object as deleted. Before submit changes this flag can be undone. Marking and rejecting the mark can be done with extension method of interface IDataObject.SetDeleted
invoice.SetDeleted(true); // mark data object for delete
...
invoice.SetDeleted(false); // undone delete mark
...
//... and little more complex example:
// set the delete flag and submit changes with submit success flag returning
return invoice.SetDeleted(true).Submit(out _);
Tip
To delete a number of objects at once, it's a handy to use ICollection<T>.SetDeleted extension method.
Submit changes
To submit changes can be used extension method of interface IDataObject Submit
newInvoice.Submit(out var invoice);
var docTypeCode = invoice.DocTypeCode;
To submit changes applied to multiple data objects of the same type can be used IRepository<T>.Submit method accepted (IEnumerable<T>) as one of parameters. When object is not changed this method will skip it while updating database.
Mapping declaration
To use the repository, required to describe the object-relational mapping rule for the type of repository objects. XData has two styles of mapping definition static - based on attribute assignment and dynamic - LINQ style mapping description.
SQL representation of samples below:
SELECT A.amount AS A_amount /* Amount */,
A.DOC_SPEC_ID AS A_DOC_SPEC_ID,
DS.doc_id AS DS_doc_id /* DocId */,
DS.doc_spec_id AS DS_doc_spec_id /* DocSpecId */,
DS.DOC_SPEC_TYPE_ID AS DS_DOC_SPEC_TYPE_ID,
ST.code AS ST_code /* Code */,
ST.DOC_SPEC_TYPE_ID AS ST_DOC_SPEC_TYPE_ID,
ST.name AS ST_name /* Name */
FROM T_DOC_SPEC DS
JOIN T_DOC_SPEC_AMOUNT A ON A.DOC_SPEC_ID = DS.DOC_SPEC_ID
JOIN T_DOC_SPEC_TYPE ST ON ST.DOC_SPEC_TYPE_ID = DS.DOC_SPEC_TYPE_ID
Static mapping description sample:
[DataObject("DS"),
DataTable("T_DOC_SPEC", "DS"),
DataTable("T_DOC_SPEC_AMOUNT", "A", Parent = "DS"),
DataTable("T_DOC_SPEC_TYPE", "ST"),
Link("A", "doc_spec_id", "DS"),
Link("ST", "doc_spec_type_id", "DS"),
Column("DocSpecId", typeof(long), "DS", Flags = DataPropertyFlag.Id),
ColumnDefault("DocSpecId", DefaultType.AutoIncrement),
Column("DocSpecTypeId", typeof(long), "ST"),
Column("DocId", typeof(long), "DS")]
public class InvoiceSpec: IDataObject
{
[Property("ST"),
LinkProperty,
LinkProperty(Property = "DocSpecTypeId"),
LinkProperty(Property = "Code")]
public Link<string, DocSpecType> Name { get; set; }
[Property("ST")]
public string Code { get { return this.GetProperty(x => x.Code); } }
[Property("A")]
public decimal Amount { get; set; }
}
Dynamic mapping description sample:
public partial class InvoiceSpec: IDataObject
{
private static Expression<CustomMapping<InvoiceSpec>> _mapping = (
() => XDataMapping.CustomMapping<InvoiceSpec>()
.DataTable("T_DOC_SPEC", "DS")
.DataTable("T_DOC_SPEC_AMOUNT", "A", "DS",
x => x.Link("DS", "doc_spec_id"))
.DataTable("T_DOC_SPEC_TYPE", "ST",
x => x.Link("DS", "doc_spec_type_id"))
.Column("DocSpecId", x => x.Field<long>("DS", string.Empty,
z => z.Key(), z => z.Default(DefaultType.AutoIncrement)))
.Column("DocSpecTypeId",
x => x.Field<long>("ST", string.Empty))
.Column("DocId", x => x.Field<long>("DS", string.Empty))
.Map(x => new InvoiceSpec {
Name = x.Link<string, DocSpecType>("ST", "name",
z => z.LinkProperty<DocSpecType>(y => y.Name),
z => z.LinkProperty<DocSpecType>((InvoiceSpec y) => y.Code)),
Amount = x.Field<decimal>("A", string.Empty)
}).SetBaseTable("DS"));
}
public partial class InvoiceSpec
{
public Link<string, DocSpecType> Name { get; set; }
public string Code { get { return this.GetProperty(x => x.Code); } }
public decimal Amount { get; set; }
}
Detailed description of static and dynamic methods of mapping described in relevant sections.


Server send this snac when you goes over rate limit or when rate parameters
changing. You can read detailed information about rate limites
here. See also
SNAC(01,07) for more info. Snac content is described by "message code".
Here is the known code list:
| 0x0001 |
Rate limits parameters changed |
| 0x0002 |
Rate limits warning (current level < alert level) |
| 0x0003 |
Rate limit hit (current level < limit level) |
| 0x0004 |
Rate limit clear (current level become > clear level) |
|
|
| 00 01 |
|
word |
|
SNAC family |
| 00 07 |
|
word |
|
SNAC subtype |
| 00 00 |
|
word |
|
SNAC flags |
| xx xx xx xx |
|
dword |
|
SNAC request-id |
|
|
| |
| xx xx |
|
word |
|
Message code (see above) |
|
|
|
| xx xx xx xx |
|
dword |
|
Window size |
| xx xx xx xx |
|
dword |
|
Clear level |
| xx xx xx xx |
|
dword |
|
Alert level |
| xx xx xx xx |
|
dword |
|
Limit level |
| xx xx xx xx |
|
dword |
|
Disconnect level |
| xx xx xx xx |
|
dword |
|
Current level |
| xx xx xx xx |
|
dword |
|
Max level |
| xx xx xx xx |
|
dword |
|
Last time; not present in protocol version 2 |
| xx |
|
byte |
|
Current state; not present in protocol version 2 |
|
|
| |
| |
|
|
|