--------------------------------------------------------------------------------
RIPPLE TODO
--------------------------------------------------------------------------------

Vinnie's List: Changes day to day, descending priority
- PeerFinder work
- Validators work
- HTTPClient improvements based on HTTPServer
- HTTPMessage improvements
- Ditch old HTTPClient so I can take the name
- Finish RPCAsyncServer, RPCService and RPCService::Manager
- Fix RPCDoor to respect config setting for [rpc_secure]
- Clean up calculation of COnfig file location.
- Remove TESTNET and all related code and settings.
- Remove addRpcSub, findRpcSub, and notify the appropriate partner(s)

David Features:
- override config items from command line
- change config via RPC, this is for debugging

--------------------------------------------------------------------------------

- std::priority_queue for DeadlineTimer

- Change ProxyInfo to use IPAddress, get rid of IPv4Address from the parsing
  code

- Validators should delay the application of newly downloaded lists from
  sources, to mitigate the effects of attacks. Unless there's no validators
  in the list.

- Validators RPC options to immediately apply UNL,
  manually revisit sources, etc...

- Look into using CMake

- IPv6 support in IPAddress

- Configuration list for Jenkins

- Fix all crash and leaks on exit
    Say there's a leak, a ledger that can never be accessed is locked in some
        structure. If the organized teardown code frees that structure, the leak
        will not be reported.
    Yes, so you'll detect some small subset of leaks that way.
    You'll still have to be vigilant for the leaks that won't detect.
    The problem is ordering. There are lots of circular dependencies.
    The biggest problem is the order of destruction of global objects. (I think)
    Getting rid of global objects is a good solution to that.
    Vinnie Falco: Those I can resolve with my ReferenceCountedSingleton. And
                  yeah thats a good approach, one that I am doing slowly anyway
    Yeah, that's good for other reasons too, not just the unpredictability of
        creation order that can hide bugs.
    There may also just be some missing destructors.
    Some of it may be things being shut down in the wrong order. Like if you shut
        down the cache and then something that uses the cache, objects may get
        put in the cache after it was shut down.

- Do something about the throw() reporting weaknesses:
  * Make sure all Sconstruct and .pro builds have debug symbols in release
  * Replace all throw with beast::Throw()
    (Only in ripple sources, not in Subtrees/, protobuf, or websocket)
  - Improved Beast exception object, provides __FILE__ and __LINE__
  - Add file and line capabilities to beast::Throw()
  - Allow beast::Throw to be hooked for logging
  - Add stack trace capability to beast::Throw() diagnostics via the hook
    (use the existing beast::SystemStats::getStackBacktrace())
  - Implement getStackBacktrace for BEAST_BSD targets
  - Add UnhandledExceptionCatcher to beast
  - Return EXIT_FAILURE on unhandled exception

- Consolidate JSON code maybe use Beast

- Deeply create directories specified in config settings

- Refactor Section code into ConfigFile

- Supress useless gcc warnings
  http://stackoverflow.com/questions/3378560/how-to-disable-gcc-warnings-for-a-few-lines-of-code

- Get rid of boost::filesystem

- What the heck is up with site_scons/site_tools/protoc.py?

- Add convenience variadic functions to JobQueue that do the bind for you

- Consolidate databases

- Figure out why we need WAL sqlite mode if we no longer use sqlite for the node store

- Add "skipped" field to beginTestCase() to disable a test but still record
  that it was skipped in the output. Like for mdb import.

- Get rid of 'ref' typedefs that really mean const&

- Use secp256k1 from beast

- Fix xsd/dtd line in JUnit XML output

- Get rid of the WriteLog() stuff in the ripple tests and make it report the
  message directly to the UnitTest object. Then update the JUnit XML output
  routines to also write the auxiliary messages.

* Restyle all the macros in ConfigSection.h

- Move src/protobuf to Subtrees and deal with protobuf_core.cpp

- Replace home-made database wrappers with beast::sqdb

- Use static creation member functions instead of endless constructor
  variations in base_uint, uint256, and family.

- Raise the warning level and fix everything

- Replace base_uint and uintXXX with UnsignedInteger
  * Need to specialize UnsignedInteger to work efficiently with 4 and 8 byte
    multiples of the size.

- Rewrite boost program_options in Beast

- Replace endian conversion calls with beast calls:
  htobe32, be32toh, ntohl, etc...
  Start by removing the system headers which provide these routines, if possible

- Rename RPCHandler to CallHandler

- Rename "fullBelow" to something like haveAllDescendants or haveAllChildren.

- Rewrite Sustain to use Beast and work on Windows as well
  * Do not enable watchdog process if a debugger is attached

- Make sure the leak detector output appears on Linux and FreeBSD debug builds.

- Rename LoadMonitor to LoadMeter, change LoadEvent to LoadMeter::ScopedSample

- Rename LedgerMaster to Ledgers, create ILedgers interface.

- Replace all NULL with nullptr

- Make TxFormats a member of ICore instead of a singleton.
  PROBLEM: STObject derived classes like STInt16 make direct use of the
           singleton. It might have to remain a singleton. At the very least,
           it should be a SharedSingleton to resolve ordering issues.

- Replace C11X with BEAST_COMPILER_SUPPORTS_MOVE_SEMANTICS

- Remove "ENABLE_INSECURE" when the time is right.

- lift unique_ptr / auto_ptr into ripple namespace,
  or replace with ScopedPointer (preferred)

- Go searching through VFALCO notes and fix everything

- Deal with function-level statics used for SqliteDatabase (like in
  HSBESQLite::visitAll)

- Document in order:
    SerializedType
    STObject
    SerializedLedgerEntry

- Consolidate SQLite database classes: DatabaseCon, Database, SqliteDatabase.

--------------------------------------------------------------------------------
WEBSOCKET TODO
--------------------------------------------------------------------------------

- Rewrite for sanity

--------------------------------------------------------------------------------
PROTOCOL BUFFERS TODO
--------------------------------------------------------------------------------

- Create/maintain the protobuf Git repo (original uses SVN)

- Update the subtree

- Make a Visual Studio 2012 Project for source browsing

--------------------------------------------------------------------------------
Davidisms
--------------------------------------------------------------------------------

(Figure out a good place to record information like this permanently)

Regarding a defect where a failing transaction was being submitted over and over
  again on the network (July 3, 2013)

  The core problem was an interaction between two bits of logic.
  1) Normally, we won't relay a transaction again if we already recently relayed
     it. But this is bypassed if the transaction failed in a way that could
     allow it to succeed later. This way, if one server discovers a transaction
     can now work, it can get all servers to retry it.
  2) Normally, we won't relay a transaction if we think it can't claim a fee.
     But if we're not sure it can't claim a fee because we're in an unhealthy
     state, we propagate the transaction to let other servers decide if they
     think it can claim a fee.
  With these two bits of logic, two unhealthy servers could infinitely propagate
     a transaction back and forth between each other.

A node is "full below" if we believe we have (either in the database or
  scheduled to be stored in the database) the contents of every node below that
  node in a hash tree. When trying to acquire a hash tree/map, if a node is
  full below, we know not to bother with anything below that node.

The fullBelowCache is a cache of hashes of nodes that are full below. Which means
  there are no missing children
