ledger-core
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
ledger::core Namespace Reference

Namespaces

 api
 
 endianness
 
 hex
 

Classes

class  AbstractAccount
 
class  AbstractAccountSynchronizer
 
class  AbstractAddress
 
class  AbstractBlockchainExplorer
 
class  AbstractBlockchainExplorerAccountSynchronizer
 
class  AbstractBlockchainObserver
 
class  AbstractBlockParser
 
class  AbstractExtendedPublicKey
 
class  AbstractLedgerApiBlockchainExplorer
 
class  AbstractLedgerApiBlockchainObserver
 
class  AbstractTransactionsBulkParser
 
class  AbstractTransactionsParser
 
class  AbstractWallet
 
class  AbstractWalletFactory
 
class  AbstractWebSocketNotificationParser
 
class  AccountDatabaseHelper
 
class  AES256
 
class  AESCipher
 
class  Amount
 
class  ApiRippleLikeBlockchainExplorer
 
class  Base58
 
class  BCHBech32
 
class  Bech32
 
class  Bech32Factory
 
class  Benchmarker
 
class  BigInt
 
class  BitcoinLikeAccount
 
class  BitcoinLikeAccountDatabase
 
struct  BitcoinLikeAccountDatabaseEntry
 
class  BitcoinLikeAccountDatabaseHelper
 
class  BitcoinLikeAccountSynchronizer
 
class  BitcoinLikeAddress
 
class  BitcoinLikeBlockApi
 
class  BitcoinLikeBlockchainExplorer
 
struct  BitcoinLikeBlockchainExplorerInput
 
struct  BitcoinLikeBlockchainExplorerOutput
 
struct  BitcoinLikeBlockchainExplorerTransaction
 
class  BitcoinLikeBlockchainObserver
 
class  BitcoinLikeBlockDatabaseHelper
 
class  BitcoinLikeCommonKeychainFactory
 
class  BitcoinLikeExtendedPublicKey
 
class  BitcoinLikeInputApi
 
class  BitcoinLikeKeychain
 
class  BitcoinLikeKeychainFactory
 
class  BitcoinLikeOperation
 
class  BitcoinLikeOutputApi
 
struct  BitcoinLikePreparedInput
 
class  BitcoinLikeScript
 
class  BitcoinLikeScriptApi
 
class  BitcoinLikeScriptChunk
 
class  BitcoinLikeScriptChunkApi
 
struct  BitcoinLikeScriptConfiguration
 
class  BitcoinLikeStrategyUtxoPicker
 
class  BitcoinLikeTransactionApi
 
class  BitcoinLikeTransactionBuilder
 
struct  BitcoinLikeTransactionBuildRequest
 
class  BitcoinLikeTransactionDatabaseHelper
 
class  BitcoinLikeUTXODatabaseHelper
 
class  BitcoinLikeUtxoPicker
 
class  BitcoinLikeWallet
 
class  BitcoinLikeWalletDatabase
 
class  BitcoinLikeWalletFactory
 
class  BitcoinLikeWritableInputApi
 
class  BLAKE
 
struct  Block
 
struct  BlockchainExplorerAccountSynchronizationBatchSavedState
 
struct  BlockchainExplorerAccountSynchronizationSavedState
 
class  BlockchainExplorerAccountSynchronizer
 
class  BlockDatabaseHelper
 
class  BlockParser
 
class  BTCBech32
 
class  Bytes
 
class  BytesReader
 
class  BytesWriter
 
class  Callback
 
class  CallbackResult
 
class  CharSequence
 
class  CommonBitcoinLikeKeychains
 
class  CompletionBlock
 
class  CompletionBlock< T, Class, false >
 
class  CompletionBlock< T, Class, true >
 
class  CompoundQueryFilter
 
class  ConditionQueryFilter
 
class  ConfigurationMatchable
 
struct  Container
 
class  CurrenciesDatabaseHelper
 
class  CurrenciesManager
 
class  CurrencyBuilder
 
class  DatabaseBackend
 
class  DatabaseSessionPool
 
class  DateUtils
 
class  DedicatedContext
 
class  Deffered
 
class  DerivationPath
 
class  DerivationPathApi
 
class  DerivationScheme
 
struct  DerivationSchemeNode
 
class  DeterministicPublicKey
 
class  DurationUtils
 
class  DynamicArray
 
class  DynamicObject
 
struct  DynamicValue
 
class  Either
 
class  ERC20LikeAccount
 
struct  ERC20LikeAccountDatabaseEntry
 
class  ERC20LikeOperation
 
class  ERC20OperationQuery
 
struct  ERC20Transaction
 
class  EthereumLikeAccount
 
struct  EthereumLikeAccountDatabaseEntry
 
class  EthereumLikeAccountDatabaseHelper
 
class  EthereumLikeAccountSynchronizer
 
class  EthereumLikeAddress
 
class  EthereumLikeBlockApi
 
class  EthereumLikeBlockchainExplorer
 
class  EthereumLikeBlockchainExplorerAccountSynchronizer
 
struct  EthereumLikeBlockchainExplorerTransaction
 
class  EthereumLikeBlockchainObserver
 
class  EthereumLikeBlockParser
 
class  EthereumLikeExtendedPublicKey
 
class  EthereumLikeKeychain
 
class  EthereumLikeKeychainFactory
 
class  EthereumLikeOperation
 
class  EthereumLikeTransactionApi
 
class  EthereumLikeTransactionBuilder
 
struct  EthereumLikeTransactionBuildRequest
 
class  EthereumLikeTransactionDatabaseHelper
 
class  EthereumLikeTransactionParser
 
class  EthereumLikeTransactionsBulkParser
 
class  EthereumLikeTransactionsParser
 
class  EthereumLikeWallet
 
class  EthereumLikeWalletDatabase
 
class  EthereumLikeWalletFactory
 
class  EthereumLikeWebSocketNotificationParser
 
class  Event
 
class  EventBus
 
class  EventEmitter
 
class  EventPublisher
 
class  EventReceiver
 
class  Exception
 
class  ExternalTezosLikeBlockchainExplorer
 
class  Fibonacci
 
class  Future
 
struct  has_complete_method
 
struct  has_complete_method< C, Ret(Args...)>
 
struct  has_on_callback_method
 
struct  has_on_callback_method< C, Ret(Args...)>
 
class  HASH160
 
class  HashAlgorithm
 
class  HMAC
 
class  HttpClient
 
class  HttpJsonHandler
 
class  HttpRequest
 
class  HttpUrlConnectionInputStream
 
class  ImmediateExecutionContext
 
class  InputParser
 
class  InternalTransaction
 
struct  InternalTx
 
class  JSONUtils
 
class  Keccak
 
struct  KeychainPersistentState
 
class  LambdaEventReceiver
 
class  LambdaRunnable
 
class  Lazy
 
class  LedgerApiBitcoinLikeBlockchainExplorer
 
class  LedgerApiBitcoinLikeBlockchainObserver
 
class  LedgerApiEthereumLikeBlockchainExplorer
 
class  LedgerApiEthereumLikeBlockchainObserver
 
class  LedgerApiParser
 
class  LockedResource
 
class  logger
 
class  LoggerApi
 
class  LoggerStreamBuffer
 
class  LogPrinterSink
 
class  MapLike
 
class  NodeRippleLikeBlockchainExplorer
 
class  NodeRippleLikeBodyRequest
 
class  NodeTezosLikeBlockchainExplorer
 
struct  Operation
 
class  OperationApi
 
class  OperationDatabaseHelper
 
class  OperationQuery
 
class  Option
 
class  OutputParser
 
class  P2PKHBitcoinLikeKeychain
 
class  P2SHBitcoinLikeKeychain
 
class  P2WPKHBitcoinLikeKeychain
 
class  P2WSHBitcoinLikeKeychain
 
class  PBKDF2
 
class  PlainTextConditionQueryFilter
 
class  PoolDatabaseHelper
 
class  Preferences
 
class  PreferencesBackend
 
struct  PreferencesChange
 
class  PreferencesEditor
 
class  ProgressNotifier
 
class  Promise
 
class  ProxyBackend
 
class  QueryBuilder
 
class  QueryFilter
 
struct  QueryFilterLink
 
class  RIPEMD160
 
class  RippleLikeAccount
 
struct  RippleLikeAccountDatabaseEntry
 
class  RippleLikeAccountDatabaseHelper
 
class  RippleLikeAccountSynchronizer
 
class  RippleLikeAddress
 
class  RippleLikeBlockApi
 
class  RippleLikeBlockchainExplorer
 
class  RippleLikeBlockchainExplorerAccountSynchronizer
 
struct  RippleLikeBlockchainExplorerTransaction
 
class  RippleLikeBlockchainObserver
 
class  RippleLikeBlockParser
 
class  RippleLikeExtendedPublicKey
 
class  RippleLikeKeychain
 
class  RippleLikeKeychainFactory
 
class  RippleLikeOperation
 
class  RippleLikeTransactionApi
 
class  RippleLikeTransactionBuilder
 
struct  RippleLikeTransactionBuildRequest
 
class  RippleLikeTransactionDatabaseHelper
 
class  RippleLikeTransactionParser
 
class  RippleLikeTransactionsBulkParser
 
class  RippleLikeTransactionsParser
 
class  RippleLikeWallet
 
class  RippleLikeWalletFactory
 
class  RippleLikeWebSocketNotificationParser
 
class  RLPDecoder
 
class  RLPEncoder
 
class  RLPListEncoder
 
class  RLPStringEncoder
 
class  RotatingEncryptableSink
 
class  Secp256k1Api
 
class  SECP256k1Point
 
class  Sequence
 
class  SHA256
 
class  SHA512
 
class  SQLite3Backend
 
class  TezosLikeAccount
 
struct  TezosLikeAccountDatabaseEntry
 
class  TezosLikeAccountDatabaseHelper
 
class  TezosLikeAccountSynchronizer
 
class  TezosLikeAddress
 
class  TezosLikeBlockApi
 
class  TezosLikeBlockchainExplorer
 
class  TezosLikeBlockchainExplorerAccountSynchronizer
 
struct  TezosLikeBlockchainExplorerOriginatedAccount
 
struct  TezosLikeBlockchainExplorerTransaction
 
class  TezosLikeBlockchainObserver
 
class  TezosLikeBlockParser
 
class  TezosLikeExtendedPublicKey
 
class  TezosLikeKeychain
 
class  TezosLikeKeychainFactory
 
class  TezosLikeOperation
 
class  TezosLikeOriginatedAccount
 
struct  TezosLikeOriginatedAccountDatabaseEntry
 
class  TezosLikeTransactionApi
 
class  TezosLikeTransactionBuilder
 
struct  TezosLikeTransactionBuildRequest
 
class  TezosLikeTransactionDatabaseHelper
 
class  TezosLikeTransactionParser
 
class  TezosLikeTransactionsBulkParser
 
class  TezosLikeTransactionsParser
 
class  TezosLikeWallet
 
class  TezosLikeWalletFactory
 
class  TezosLikeWebSocketNotificationParser
 
class  TezosOperationQuery
 
class  TezosOriginatedOperationQuery
 
class  TransactionParser
 
class  TransactionsBulkParser
 
class  TransactionsParser
 
class  TrustIndicator
 
class  Try
 
class  TTLCache
 
class  Unit
 
class  URI
 
class  VectorUtils
 
struct  WalletDatabaseEntry
 
class  WalletPool
 
class  WalletPoolApi
 
class  WalletPoolBuilder
 
class  WebSocketClient
 
class  WebSocketConnection
 
class  WebSocketConnImpl
 
class  WebSocketNotificationParser
 
class  zarith
 

Typedefs

template<typename T >
using FuturePtr = Future< std::shared_ptr< T > >
 
template<typename T >
using PromisePtr = Promise< std::shared_ptr< T > >
 
using BitcoinExtendedPublicKey = AbstractExtendedPublicKey< api::BitcoinLikeNetworkParameters >
 
using rlp_tuple = std::tuple< int, int, RLP_TYPES >
 
template<typename K , typename V >
using Map = MapLike< K, V, std::unordered_map< K, V > >
 
template<typename T >
using Array = Sequence< T, std::vector< T > >
 
template<typename T >
using List = Sequence< T, std::vector< T > >
 
using String = CharSequence< char, std::string >
 
using EthereumExtendedPublicKey = AbstractExtendedPublicKey< api::EthereumLikeNetworkParameters >
 
typedef std::function< bool(const std::shared_ptr< api::Event > &)> EventFilter
 
using ProgressHandler = std::function< void(const std::string &, double)>
 
using WebSocketEventHandler = std::function< void(WebSocketEventType, const std::shared_ptr< WebSocketConnection > &connection, const Option< std::string > &message, Option< api::ErrorCode >)>
 
using RippleExtendedPublicKey = AbstractExtendedPublicKey< api::RippleLikeNetworkParameters >
 
using TezosExtendedPublicKey = AbstractExtendedPublicKey< api::TezosLikeNetworkParameters >
 
template<typename T >
using OptionPtr = Option< std::shared_ptr< T > >
 
template<typename T >
using optional = std::experimental::optional< T >
 
template<typename T >
using TryPtr = Try< std::shared_ptr< T > >
 
using LedgerApiBlockchainExplorer = AbstractLedgerApiBlockchainExplorer< BitcoinLikeBlockchainExplorerTransaction, BitcoinLikeBlockchainExplorer::TransactionsBulk, TransactionsParser, TransactionsBulkParser, BlockParser, api::BitcoinLikeNetworkParameters >
 
using BitcoinBlockchainObserver = AbstractBlockchainObserver< BitcoinLikeAccount, BitcoinLikeBlockchainExplorerTransaction, BitcoinLikeBlockchainExplorer::Block >
 
using BitcoinLikeScriptOpCode = btccore::opcodetype
 
using BlockchainAccountSynchronizer = AbstractBlockchainExplorerAccountSynchronizer< BitcoinLikeAccount, BitcoinLikeAddress, BitcoinLikeKeychain, BitcoinLikeBlockchainExplorer >
 
using BitcoinLikeTransactionBuildFunction = std::function< Future< std::shared_ptr< api::BitcoinLikeTransaction > >(const BitcoinLikeTransactionBuildRequest &)>
 
using BitcoinLikeGetUtxoFunction = std::function< Future< std::vector< std::shared_ptr< api::BitcoinLikeOutput > >>()>
 
using BitcoinLikeGetTxFunction = std::function< FuturePtr< BitcoinLikeBlockchainExplorerTransaction >(const std::string &)>
 
using BitcoinLikeApiUtxoVector = std::vector< std::shared_ptr< api::BitcoinLikeOutput > >
 
using BitcoinLikeApiOutputVector = BitcoinLikeApiUtxoVector
 
using LedgerApiEthBlockchainExplorer = AbstractLedgerApiBlockchainExplorer< EthereumLikeBlockchainExplorerTransaction, EthereumLikeBlockchainExplorer::TransactionsBulk, EthereumLikeTransactionsParser, EthereumLikeTransactionsBulkParser, EthereumLikeBlockParser, api::EthereumLikeNetworkParameters >
 
using EthereumLikeAccountSynchronizerFactory = std::function< std::shared_ptr< EthereumLikeAccountSynchronizer >()>
 
using EthereumBlockchainObserver = AbstractBlockchainObserver< EthereumLikeAccount, EthereumLikeBlockchainExplorerTransaction, EthereumLikeBlockchainExplorer::Block >
 
using EthereumBlockchainAccountSynchronizer = AbstractBlockchainExplorerAccountSynchronizer< EthereumLikeAccount, EthereumLikeAddress, EthereumLikeKeychain, EthereumLikeBlockchainExplorer >
 
using EthereumLikeTransactionBuildFunction = std::function< Future< std::shared_ptr< api::EthereumLikeTransaction > >(const EthereumLikeTransactionBuildRequest &, const std::shared_ptr< EthereumLikeBlockchainExplorer > &)>
 
using RippleLikeAccountSynchronizerFactory = std::function< std::shared_ptr< RippleLikeAccountSynchronizer >()>
 
using RippleBlockchainObserver = AbstractBlockchainObserver< RippleLikeAccount, RippleLikeBlockchainExplorerTransaction, RippleLikeBlockchainExplorer::Block >
 
using RippleBlockchainAccountSynchronizer = AbstractBlockchainExplorerAccountSynchronizer< RippleLikeAccount, RippleLikeAddress, RippleLikeKeychain, RippleLikeBlockchainExplorer >
 
using RippleLikeTransactionBuildFunction = std::function< Future< std::shared_ptr< api::RippleLikeTransaction > >(const RippleLikeTransactionBuildRequest &, const std::shared_ptr< RippleLikeBlockchainExplorer > &)>
 
using ExternalApiBlockchainExplorer = AbstractLedgerApiBlockchainExplorer< TezosLikeBlockchainExplorerTransaction, TezosLikeBlockchainExplorer::TransactionsBulk, TezosLikeTransactionsParser, TezosLikeTransactionsBulkParser, TezosLikeBlockParser, api::TezosLikeNetworkParameters >
 
using TezosLikeAccountSynchronizerFactory = std::function< std::shared_ptr< TezosLikeAccountSynchronizer >()>
 
using TezosBlockchainObserver = AbstractBlockchainObserver< TezosLikeAccount, TezosLikeBlockchainExplorerTransaction, TezosLikeBlockchainExplorer::Block >
 
using TezosBlockchainAccountSynchronizer = AbstractBlockchainExplorerAccountSynchronizer< TezosLikeAccount, TezosLikeAddress, TezosLikeKeychain, TezosLikeBlockchainExplorer >
 
using TezosLikeTransactionBuildFunction = std::function< Future< std::shared_ptr< api::TezosLikeTransaction > >(const TezosLikeTransactionBuildRequest &, const std::shared_ptr< TezosLikeBlockchainExplorer > &)>
 

Enumerations

enum  RLP_TYPES { bytes, bytesVector }
 
enum  QueryFilterOperator { OP_AND, OP_OR, OP_AND_NOT, OP_OR_NOT }
 
enum  WebSocketEventType { CONNECT, RECEIVE, CLOSE }
 
enum  PreferencesChangeType { PUT_TYPE, DELETE_TYPE }
 
enum  DerivationSchemeLevel {
  COIN_TYPE, ACCOUNT_INDEX, NODE, ADDRESS_INDEX,
  UNDEFINED
}
 
enum  FieldTypes { NumberType, StringType }
 

Functions

template<typename T , class Class >
std::shared_ptr< CompletionBlock< T, Class, has_complete_method< Class, void(const std::shared_ptr< T > &, const std::experimental::optional< api::Error > &)>::value > > make_api_completion_block ()
 
template<typename T >
Future< std::vector< T > > executeAll (const std::shared_ptr< api::ExecutionContext > &context, std::vector< Future< T >> &futures)
 
std::string toBech32Helper (const std::string &keychainEngine, const std::vector< uint8_t > &hash160, const api::BitcoinLikeNetworkParameters &params)
 
template<>
void DynamicValue::serialize< cereal::PortableBinaryOutputArchive > (cereal::PortableBinaryOutputArchive &ar)
 
template<>
void DynamicValue::serialize< cereal::PortableBinaryInputArchive > (cereal::PortableBinaryInputArchive &ar)
 
template<>
void DynamicValue::serialize< cereal::BinaryOutputArchive > (cereal::BinaryOutputArchive &ar)
 
template<>
void DynamicValue::serialize< cereal::BinaryInputArchive > (cereal::BinaryInputArchive &ar)
 
String operator"" _S (const char *str, size_t size)
 
int getDatabaseMigrationVersion (soci::session &sql)
 Get the current database migration version.
 
template<>
bool migrate<-1 > (soci::session &sql, int currentVersion)
 
template<>
void rollback<-1 > (soci::session &sql, int currentVersion)
 
template<>
void migrate< 0 > (soci::session &sql)
 
template<>
void rollback< 0 > (soci::session &sql)
 
template<>
void migrate< 1 > (soci::session &sql)
 
template<>
void rollback< 1 > (soci::session &sql)
 
template<>
void migrate< 2 > (soci::session &sql)
 
template<>
void rollback< 2 > (soci::session &sql)
 
template<>
void migrate< 3 > (soci::session &sql)
 
template<>
void rollback< 3 > (soci::session &sql)
 
template<>
void migrate< 4 > (soci::session &sql)
 
template<>
void rollback< 4 > (soci::session &sql)
 
template<>
void migrate< 5 > (soci::session &sql)
 
template<>
void rollback< 5 > (soci::session &sql)
 
template<>
void migrate< 6 > (soci::session &sql)
 
template<>
void rollback< 6 > (soci::session &sql)
 
template<>
void migrate< 7 > (soci::session &sql)
 
template<>
void rollback< 7 > (soci::session &sql)
 
template<>
void migrate< 8 > (soci::session &sql)
 
template<>
void rollback< 8 > (soci::session &sql)
 
template<>
void migrate< 9 > (soci::session &sql)
 
template<>
void rollback< 9 > (soci::session &sql)
 
template<>
void migrate< 10 > (soci::session &sql)
 
template<>
void rollback< 10 > (soci::session &sql)
 
template<>
void migrate< 11 > (soci::session &sql)
 
template<>
void rollback< 11 > (soci::session &sql)
 
template<>
void migrate< 12 > (soci::session &sql)
 
template<>
void rollback< 12 > (soci::session &sql)
 
template<>
void migrate< 13 > (soci::session &sql)
 
template<>
void rollback< 13 > (soci::session &sql)
 
template<>
void migrate< 14 > (soci::session &sql)
 
template<>
void rollback< 14 > (soci::session &sql)
 
template<>
void migrate< 15 > (soci::session &sql)
 
template<>
void rollback< 15 > (soci::session &sql)
 
template<>
void migrate< 16 > (soci::session &sql)
 
template<>
void rollback< 16 > (soci::session &sql)
 
template<>
void migrate< 17 > (soci::session &sql)
 
template<>
void rollback< 17 > (soci::session &sql)
 
template<int migrationNumber>
void migrate (soci::session &sql)
 
template<int version>
bool migrate (soci::session &sql, int currentVersion)
 
template<int version>
void rollback (soci::session &sql)
 
template<int version>
void rollback (soci::session &sql, int currentVersion)
 
std::shared_ptr< api::Event > make_event (api::EventCode code, const std::shared_ptr< api::DynamicObject > &payload)
 
std::shared_ptr< LambdaEventReceiver > make_receiver (std::function< void(const std::shared_ptr< api::Event > &)> f)
 
template<typename... Args>
Exception make_exception (api::ErrorCode code, const std::string &format, const Args &... args)
 
template<typename... Args>
Exception make_exception (api::ErrorCode code, std::shared_ptr< void > userData, const std::string &format, const Args &... args)
 
std::shared_ptr< api::Runnable > make_runnable (std::function< void()> func)
 
template<typename T >
Option< std::shared_ptr< T > > make_option (const std::shared_ptr< T > &ptr)
 
template<typename T >
Try< T > make_try (std::function< T()> lambda)
 
template<>
std::shared_ptr< AbstractWalletFactory > make_factory< api::WalletType::BITCOIN > (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
template<>
std::shared_ptr< AbstractWalletFactory > make_factory< api::WalletType::ETHEREUM > (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
template<>
std::shared_ptr< AbstractWalletFactory > make_factory< api::WalletType::RIPPLE > (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
template<>
std::shared_ptr< AbstractWalletFactory > make_factory< api::WalletType::TEZOS > (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
template<>
std::shared_ptr< AbstractWalletFactory > make_factory< api::WalletType::MONERO > (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
template<api::WalletType >
std::shared_ptr< AbstractWalletFactory > make_factory (const api::Currency &currency, const std::shared_ptr< WalletPool > &pool)
 
CurrencyBuilder Currency (const std::string &name)
 
bool writeLengthPrefix (BytesWriter &writer, uint64_t size)
 
uint64_t readLengthPrefix (BytesReader &reader)
 

Variables

const char * charset = "qpzry9x8gf2tvdw0s3jn54khce6mua7l"
 
const int8_t charsetRev [128]
 
const int LIB_VERSION = LIB_VERSION_MAJOR << 16 | LIB_VERSION_MINOR << 8 | LIB_VERSION_PATCH
 
const int VERSION_MAJOR = LIB_VERSION_MAJOR
 
const int VERSION_MINOR = LIB_VERSION_MINOR
 
const int VERSION_PATCH = LIB_VERSION_PATCH
 
const std::string LIB_STRING_VERSION
 
const Unit unit {}
 
const uint64_t XRP_EPOCH_SECONDS_FROM_UNIX_EPOCH = 946684800
 

Detailed Description

Ledger core root namespace

Function Documentation

◆ rollback()

template<int version>
void ledger::core::rollback ( soci::session &  sql,
int  currentVersion 
)

Rollback all migrations down.

This is a bit like dropping the content of the database, but does it in a more correct and portable way. Also, it enables possible partial rollbacks, even though the current implementation doesn’t.

Variable Documentation

◆ charsetRev

const int8_t ledger::core::charsetRev[128]
Initial value:
= {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
15, -1, 10, 17, 21, 20, 26, 30, 7, 5, -1, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1,
-1, 29, -1, 24, 13, 25, 9, 8, 23, -1, 18, 22, 31, 27, 19, -1,
1, 0, 3, 16, 11, 28, 12, 14, 6, 4, 2, -1, -1, -1, -1, -1
}

◆ LIB_STRING_VERSION

LIBCORE_EXPORT const std::string ledger::core::LIB_STRING_VERSION
Initial value:
=
BOOST_PP_STRINGIZE(LIB_VERSION_MAJOR) "."
BOOST_PP_STRINGIZE(LIB_VERSION_MINOR) "."
BOOST_PP_STRINGIZE(LIB_VERSION_PATCH)
Generated by   doxygen 1.8.13