Merge branch 'master' of git://github.com/AlericInglewood/SingularityViewer
Merge branch 'master' of github.com:singularity-viewer/SingularityViewer
Merge remote-tracking branch 'shyotl/sunshine'
Merge remote-tracking branch 'upstream/master'
Merge branch 'master' of github.com:singularity-viewer/SingularityViewer
Moved RLVa menu back to advanced by default
Minor french translation update, thanks Nomade~
Fix Issue 628: Currency exchanges no longer notify in chat
Override the viewer's Z offset with the RLV one, if the RLV one has been set.
Fix Sappa's issue with getString log spam, three strings weren't quite in the right xml.
Added documentation on LLHTTPClient Responders.
Renamed deferred rendering switch from 'Lightning and Shadows' to 'Advanced Lighting Model' as per upstream
Merge remote-tracking branch 'singu/master'
Make the type of the read/write lock of AIThreadSafe a template parameter.

This allows passing a different type than the default AIRWLock for
debugging purposes.

The signature of the class used for RWLOCK should be:

struct RWLock {
  // Default constructor.
  RWLock(void);

  // Block until it's safe to read the data.
  // high_priority is a hint that granting this thread the read lock is more important than granting another thread a write lock.
  void rdlock(bool high_priority = false);
  // Release the obtained read lock.
  void rdunlock();
  // Block until it's safe to write to the data.
  void wrlock();
  // Release the obtained write lock.
  void wrunlock();
  // Convert the obtained write lock into a read lock.
  void wr2rdlock();
  // Block until it is possible to convert the obtained read lock into a write lock.
  void rd2wrlock();

  // Return true when a read or write is obtained and subsequent calls to release the lock are expected.
  bool isLocked() const;
};
Add AINRLock for debugging purposes.

This class can be used as RWLOCK parameter to AIThreadSafe to check that
data is only accessed by a single thread (like
AIThreadSafeSingleThreaded) AND is never write locked when a read or
write lock was already obtained (by the same thread). It doesn't
actually lock anything, it just keeps track if the "lock" was obtained
before. The use case is to check if STL containers aren't being used
(read or write locked) by a calling function when additional write
access is necessary, as write access might invalidate iterator that
point to the container (where the previous lock was taken).
Remove unused variable.
Use viewList_t and child_list_t in appropriate places.

Both types are currently the same, but soon they will be made different.
Currently they are used a bit mixed up. This patch fixes that.
Wrap LLView::child_list_t in a class AIList.

So far not doing anything. Iterators already keep a pointer to the
container they belong to.
Do not pre- increment the loop iterator in LLView::drawChildren

This is in fact much safer, because the only way to invalidate an
interator in the first place (in this code) is by calling removeChild,
which *already* has an assert never to remove a child that is being
iterated over (by means of the mInDraw flag).
Make AIList resilient against invalidating iterators.

This adds a counter and a 'dead' flag to the data stored in the linked
list. The counter counts the number of iterators (still) pointing to an
element and the dead flag is set to indicate the element was erased when
iterators are still pointing to it. As a result, iterators are NEVER
invalidated. Of course, such elements are subsequentially skipped when
iterating over the list. Assertions protect against dereferencing an
erased iterator, but incrementing or decremention still works: it is
still well-defined what the next (non erased) element is, assuming the
element wasn't erased (yet), but would be erased delayed - or assuming
the iterator would have been incremented (decremented) in advance to
erasing the element.