Buffer with an embedded pre-reserved space.It is convenient to use if you want to avoid allocation in heap for smaller requested sizes, and use stack for such cases.
#ifndef CORELIB___NCBIMISC__HPP
#define CORELIB___NCBIMISC__HPP
#include <stdlib.h>
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#if !defined(HAVE_NULLPTR) && !defined(nullptr)
# define nullptr NULL
#endif
#ifndef NCBI_ESWITCH_DEFINED
#define NCBI_ESWITCH_DEFINED
extern "C" {
}
#endif
#ifndef NCBI_EOWNERSHIP_DEFINED
#define NCBI_EOWNERSHIP_DEFINED
extern "C" {
}
#endif
};
};
};
};
};
};
};
};
#define DECLARE_SAFE_BOOL_METHOD(Expr) \
struct SSafeBoolTag { \
void SafeBoolTrue(SSafeBoolTag*) {} \
}; \
typedef void (SSafeBoolTag::*TBoolType)(SSafeBoolTag*); \
operator TBoolType() const { \
return (Expr)? &SSafeBoolTag::SafeBoolTrue: 0; \
} \
private: \
bool operator==(TBoolType) const; \
bool operator!=(TBoolType) const; \
public: \
friend struct SSafeBoolTag
#define DECLARE_OPERATOR_BOOL(Expr) \
DECLARE_SAFE_BOOL_METHOD(Expr)
#define DECLARE_OPERATOR_BOOL_PTR(Ptr) \
DECLARE_OPERATOR_BOOL((Ptr) != 0)
#define DECLARE_OPERATOR_BOOL_REF(Ref) \
DECLARE_OPERATOR_BOOL((Ref).NotNull())
#define OVERRIDE_OPERATOR_BOOL(TAncestorClass, NewBoolExpr) \
using TAncestorClass::TBoolType; \
using TAncestorClass::SSafeBoolTag; \
operator TBoolType() const { \
return (NewBoolExpr)? & SSafeBoolTag::SafeBoolTrue : 0; \
}
template<class Base, class Member>
{
public:
{
}
{
}
{
}
{
return *this;
}
{
return *this;
}
{
}
{
}
{
if (
static_cast<void*
>(&
first()) !=
static_cast<void*
>(&
second())){
}
}
private:
};
template <class TEnum>
{
public:
operator TEnum ()
const {
return TEnum(
m_Value); }
private:
private:
operator unsigned int()
const;
};
template<class X>
{
{ return new X; }
};
template<class X>
{
{ delete object; }
};
template<class X>
{
{ delete[] object; }
};
template<class X>
{
};
template< class X, class Del = Deleter<X> >
{
public:
{ }
{ }
{ }
{ }
{
}
{
}
{
if (this != &p) {
}
return *this;
}
{
return *this;
}
{
}
{
}
}
}
{
}
private:
{
}
};
template< class X, class Del = ArrayDeleter<X> >
{
public:
public:
{ }
{ }
{ }
{
}
{
}
{
if (this != &p) {
}
return *this;
}
{
return *this;
}
{
}
{
}
}
}
{
}
private:
{
}
private:
};
#ifdef __cpp_using_enum
null = 0
};
#else
null = 0
};
#endif
template <class TValue>
{
{
}
};
template <class TValue, class TNullToValue = SThrowOnNull<TValue> >
{
public:
{
}
operator TValue(void) const
{
}
{
const_cast<TValue&
>(
m_Value) = TNullToValue()();
}
}
{
*this = TNullToValue()();
}
}
{
return *this;
}
{
return *this;
}
private:
};
template <class TValue, class TNullToValue = SThrowOnNull<TValue> >
{
return (
l.IsNull() &&
r.IsNull()) ||
(!
l.IsNull() && !
r.IsNull() &&
l.GetValue() ==
r.GetValue());
}
template <class TValue, class TNullToValue = SThrowOnNull<TValue> >
{
}
#ifdef min
# undef min
#endif
#ifdef max
# undef max
#endif
#ifndef HAVE_STRDUP
#endif
template<typename Type>
{
return obj;
}
#define ITERATE_CONST(Cont) NCBI_NS_NCBI::s_ITERATE_ConstRef(Cont)
#ifdef _DEBUG
template<typename Type>
{
return &obj1 == &obj2;
}
# define ITERATE_BEGIN(Cont, Begin) \
(NCBI_ASSERT_EXPR(NCBI_NS_NCBI::s_ITERATE_SameObject(Cont, Cont), \
"rvalue container in *ITERATE"), (Cont).Begin())
#else
# define ITERATE_BEGIN(Cont, Begin) ((Cont).Begin())
#endif
#if 0 && defined(NCBI_HAVE_CXX11)
# define ITERATE_VAR(Type) auto
#else
# define ITERATE_VAR(Type) Type
#endif
#define ITERATE(Type, Var, Cont) \
for ( ITERATE_VAR(Type::const_iterator) \
Var = ITERATE_BEGIN(ITERATE_CONST(Cont), begin), \
NCBI_NAME2(Var,_end) = ITERATE_CONST(Cont).end(); \
Var != NCBI_NAME2(Var,_end); ++Var )
#define NON_CONST_ITERATE(Type, Var, Cont) \
for ( ITERATE_VAR(Type::iterator) Var = ITERATE_BEGIN(Cont, begin); \
Var != (Cont).end(); ++Var )
#define REVERSE_ITERATE(Type, Var, Cont) \
for ( ITERATE_VAR(Type::const_reverse_iterator) \
Var = ITERATE_BEGIN(ITERATE_CONST(Cont), rbegin), \
NCBI_NAME2(Var,_end) = ITERATE_CONST(Cont).rend(); \
Var != NCBI_NAME2(Var,_end); ++Var )
#define NON_CONST_REVERSE_ITERATE(Type, Var, Cont) \
for ( ITERATE_VAR(Type::reverse_iterator) \
Var = ITERATE_BEGIN(Cont, rbegin); \
Var != (Cont).rend(); ++Var )
#define ERASE_ITERATE(Type, Var, Cont) \
for ( ITERATE_VAR(Type::iterator) Var = ITERATE_BEGIN(Cont, begin), \
NCBI_NAME2(Var,_next) = Var; \
(Var = NCBI_NAME2(Var,_next)) != (Cont).end() && \
(++NCBI_NAME2(Var,_next), true); )
#define VECTOR_ERASE(Var, Cont) (NCBI_NAME2(Var,_next) = (Cont).erase(Var))
#define ITERATE_BOTH_BOOL_VALUES(BoolVar) \
for( bool BoolVar##BOTH_BOOL_VALUES_DONE##__LINE__ = false, BoolVar = false; ! BoolVar##BOTH_BOOL_VALUES_DONE##__LINE__ ; BoolVar##BOTH_BOOL_VALUES_DONE##__LINE__ = BoolVar, BoolVar = true )
#define ITERATE_0_IDX(idx, up_to) \
for( TSeqPos idx = 0; idx < up_to; ++idx )
#define ITERATE_SIMPLE(num_iters) \
ITERATE_0_IDX( _dummy_idx_94768308_##__LINE__, num_iters )
template<class TKey, class TStorage>
{
public:
#if !defined(NCBI_TEST_APPLICATION)
template<typename T>
private:
#else
template<typename T>
template<typename T>
template<typename T>
operator T(
void)
const {
return static_cast<T>(
m_Id); }
#endif
private:
};
template<class TKey, class TStorage>
inline
{
}
template<class TKey, class TStorage>
inline
{
}
#if defined(NCBI_INT4_GI)
# ifdef NCBI_INT8_GI
# error "Both NCBI_INT4_GI and NCBI_INT8_GI must not be defined!"
# endif
# ifdef NCBI_STRICT_GI
# error "Both NCBI_INT4_GI and NCBI_STRICT_GI must not be defined!"
# endif
#elif !defined(NCBI_INT8_GI)
# define NCBI_INT8_GI
#endif
#ifdef NCBI_TEST_STRICT_ENTREZ_ID
#define NCBI_STRICT_ENTREZ_ID
#else
# ifdef NCBI_STRICT_ENTREZ_ID
# undef NCBI_STRICT_ENTREZ_ID
# endif
#endif
#ifndef NCBI_STRICT_GI
# undef NCBI_STRICT_ENTREZ_ID
# undef NCBI_STRICT_TAX_ID
#endif
#ifdef NCBI_INT8_GI
#else
#endif
};
};
};
#ifdef NCBI_STRICT_GI
#else
#endif
#ifdef NCBI_STRICT_ENTREZ_ID
#else
#endif
#ifdef NCBI_STRICT_TAX_ID
#else
#endif
template<class TId, TId id>
public:
#ifndef NCBI_COMPILER_MSVC
enum : TId {
};
#else
static const TId
value = id;
#endif
};
#ifdef NCBI_STRICT_GI
#define STRICT_ID_TO(TId, TInt, id) (static_cast<TInt>((id).Get()))
#define STRICT_ID_FROM(TIdType, TIntType, id) (TIdType(static_cast<TIdType::TId>(id)))
#define STRICT_ID_CONST(type, id) \
(type(static_cast<type::TId>(ncbi::CConstIdChecker<type::TId, id>::value)))
#define STRICT_ID_ZERO(type) STRICT_ID_CONST(type, 0)
#define STRICT_ID_INVALID(type) STRICT_ID_CONST(type, -1)
#else
#define STRICT_ID_TO(TId, TInt, id) (static_cast<TInt>(id))
#define STRICT_ID_FROM(TIdType, TIntType, id) (static_cast<TIdType>(id))
#define STRICT_ID_CONST(type, id) (ncbi::CConstIdChecker<type, id>::value)
#define STRICT_ID_ZERO(type) type(0)
#define STRICT_ID_INVALID(type) type(-1)
#endif
#define GI_TO(T, gi) STRICT_ID_TO(ncbi::TGi, T, gi)
#define GI_FROM(T, value) STRICT_ID_FROM(ncbi::TGi, T, value)
#define GI_CONST(gi) STRICT_ID_CONST(ncbi::TGi, gi)
#define ZERO_GI STRICT_ID_ZERO(ncbi::TGi)
#define INVALID_GI STRICT_ID_INVALID(ncbi::TGi)
#ifdef NCBI_STRICT_ENTREZ_ID
# define ENTREZ_ID_TO(T, entrez_id) STRICT_ID_TO(ncbi::TEntrezId, T, entrez_id)
# define ENTREZ_ID_FROM(T, value) STRICT_ID_FROM(ncbi::TEntrezId, T, value)
# define ENTREZ_ID_CONST(id) STRICT_ID_CONST(ncbi::TEntrezId, id)
#else
# define ENTREZ_ID_TO(T, entrez_id) (static_cast<T>(entrez_id))
# define ENTREZ_ID_FROM(T, value) (static_cast<ncbi::TEntrezId>(value))
# define ENTREZ_ID_CONST(id) id
#endif
#define ZERO_ENTREZ_ID ENTREZ_ID_CONST(0)
#define INVALID_ENTREZ_ID ENTREZ_ID_CONST(-1)
#ifdef NCBI_STRICT_TAX_ID
# define TAX_ID_TO(T, tax_id) STRICT_ID_TO(ncbi::TTaxId, T, tax_id)
# define TAX_ID_FROM(T, value) STRICT_ID_FROM(ncbi::TTaxId, T, value)
# define TAX_ID_CONST(id) STRICT_ID_CONST(ncbi::TTaxId, id)
#else
# define TAX_ID_TO(T, tax_id) (static_cast<T>(tax_id))
# define TAX_ID_FROM(T, value) (static_cast<ncbi::TTaxId>(value))
# define TAX_ID_CONST(id) id
#endif
#define ZERO_TAX_ID TAX_ID_CONST(0)
#define INVALID_TAX_ID TAX_ID_CONST(-1)
#define INT_ID_TO(T, id) (static_cast<T>(id))
#define INT_ID_FROM(T, value) (static_cast<ncbi::TIntId>(value))
{
public:
};
inline
{
return static_cast<char*
> (object) +
offset;
}
inline
{
return static_cast<const char*
> (object) +
offset;
}
inline
{
(
static_cast<const char*
> (
first) -
static_cast<const char*
> (second));
}
template <size_t KEmbeddedSize, class TType = char>
{
public:
{}
private:
};
#if defined(NCBI_COMPILER_MSVC) || defined(NCBI_COMPILER_VISUALAGE)
# define NCBI_DEPRECATED_CTOR(decl) NCBI_DEPRECATED decl
#else
# define NCBI_DEPRECATED_CTOR(decl) decl NCBI_DEPRECATED
#endif
#define NCBI_DEPRECATED_CLASS NCBI_DEPRECATED_CTOR(class)
#ifdef NCBI_ENABLE_SAFE_FLAGS
template<class Enum>
public:
{
}
explicit
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
return *this;
}
{
}
{
return *this;
}
{
}
{
return *this;
}
private:
};
#define DECLARE_SAFE_FLAGS_TYPE(E, T) \
typedef NCBI_NS_NCBI::CSafeFlags<E> T
#define DECLARE_SAFE_FLAGS(E) \
inline NCBI_NS_NCBI::CSafeFlags<E> operator|(E a, E b) \
{ return NCBI_NS_NCBI::CSafeFlags<E>(a) | b; } \
inline NCBI_NS_NCBI::CSafeFlags<E> operator&(E a, E b) \
{ return NCBI_NS_NCBI::CSafeFlags<E>(a) & b; } \
inline NCBI_NS_NCBI::CSafeFlags<E> operator^(E a, E b) \
{ return NCBI_NS_NCBI::CSafeFlags<E>(a) ^ b; } \
inline NCBI_NS_NCBI::CSafeFlags<E> operator~(E a) \
{ return ~NCBI_NS_NCBI::CSafeFlags<E>(a); }
{
}
{
}
{
}
template<class E> inline
{
}
#else
# define DECLARE_SAFE_FLAGS_TYPE(Enum,Typedef) typedef underlying_type<Enum>::type Typedef
# define DECLARE_SAFE_FLAGS(Enum) NCBI_EAT_SEMICOLON(safe_flags)
#endif
{
public:
{
m_Actions.push_back(unique_ptr<CAction_Base>(
new CAction<TFunc>(func)));
}
{
try {
(*it)->Execute();
}
catch (exception& e) {
ERR_POST(
"Error executing action: " << e.what());
}
}
}
private:
class CAction_Base
{
public:
virtual void Execute(
void)
const = 0;
private:
};
template<class TFunc> class CAction : public CAction_Base
{
public:
private:
};
typedef list<unique_ptr<CAction_Base> >
TActions;
};
template <class T>
template <class T, typename TDeleter>
{
return {p, d};
}
template <class T>
{
}
#define NCBI_EXPORT_FUNC_DECLARE(lib, func) \
namespace NCBI_ ## lib \
{ \
namespace S ## func \
{ \
using T = decltype(func); \
\
NCBI_ ## lib ## _EXPORT T* F(); \
\
template <class T> \
struct S; \
\
template <class TR, class... TArgs> \
struct S<TR (TArgs...)> \
{ \
static TR Call(TArgs... args) { return F()(args...); } \
}; \
} \
\
constexpr auto func = S ## func::S<S ## func::T>::Call; \
}
#define NCBI_EXPORT_FUNC_DEFINE(lib, func) \
namespace NCBI_ ## lib \
{ \
namespace S ## func \
{ \
T* F() { return ::func; } \
} \
}
template<class T1, class T2>
inline
void swap(NCBI_NS_NCBI::pair_base_member<T1,T2>& pair1,
NCBI_NS_NCBI::pair_base_member<T1,T2>& pair2)
{
pair1.Swap(pair2);
}
template<class P, class D>
inline
void swap(NCBI_NS_NCBI::AutoPtr<P,D>& ptr1,
NCBI_NS_NCBI::AutoPtr<P,D>& ptr2)
{
ptr1.Swap(ptr2);
}
#if defined(NCBI_COMPILER_WORKSHOP) || defined(NCBI_COMPILER_MIPSPRO)
#define ArraySize(array) (sizeof(array)/sizeof((array)[0]))
#else
template<class Element, size_t Size>
inline
{
return Size;
}
#ifdef NCBI_STRICT_GI
{
size_t operator()(const ncbi::CStrictId<TKey, TStorage> & x) const
{
}
};
#endif
#endif
#endif
bool operator!=(const _Ht_iterator< _Val, _Nonconst_traits< _Val >, _Key, _HF, _ExK, _EqK, _All > &__x, const _Ht_iterator< _Val, _Const_traits< _Val >, _Key, _HF, _ExK, _EqK, _All > &__y)
Template used to replace bool type arguments with some strict equivalent.
a helper template to enforce constness of argument to GI_CONST macro
CNcbiActionGuard class Executes registered callbacks on request or on destruction.
Template class allowing to store a value or null (unassigned) state.
Support for safe enum flags.
Template class for strict ID types.
Template used for empty base class optimization.
bool operator==(const CEquivRange &A, const CEquivRange &B)
CNcbiOstream & operator<<(CNcbiOstream &out, const CEquivRange &range)
std::ofstream out("events_result.xml")
main entry point for tests
static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)
static const char * str(char *buf, int n)
CNcbiIstream & operator>>(CNcbiIstream &s, const getcontig &c)
element_type * m_Ptr
Internal pointer representation.
TValue operator()(void) const
virtual ~CNcbiActionGuard(void)
SStrictId_Entrez::TId TEntrezId
TEntrezId type for entrez ids which require the same strictness as TGi.
const Type & s_ITERATE_ConstRef(const Type &obj)
NCBI_XNCBI_EXPORT void g_ThrowOnNull(void)
Del deleter_type
Alias for template argument.
#define DECLARE_OPERATOR_BOOL(Expr)
Declaration of safe bool operator from boolean expression.
~AutoPtr(void)
Destructor.
CNcbiActionGuard & operator=(const CNcbiActionGuard &)
ETriState
Enumeration to represent a tristate value.
CSafeFlags operator~() const
AutoPtr< X, Del > & operator=(const AutoPtr< X, Del > &p)
Assignment operator.
void AddAction(TFunc func)
CAction_Base & operator=(const CAction_Base &)
X element_type
Define element type.
CSafeFlags & operator|=(const CSafeFlags &b)
bool operator==(TBoolType) const
element_type * x_Release(void) const
Release for const object.
void reset(element_type *p=0, EOwnership ownership=eTakeOwnership)
Reset will delete the old pointer (if owned), set content to the new value, and assume the ownership ...
void ExecuteActions(void)
CSafeFlags operator&(const CSafeFlags &b) const
ERetriable
Can the action be retried?
void Swap(AutoPtr< X, Del > &a)
void Swap(pair_base_member< first_type, second_type > &p)
pair_base_member< deleter_type, bool > m_Data
State info.
bool operator<(const TThis &id) const
element_type & operator*(void) const
Dereference operator.
CSafeFlags operator|(const CSafeFlags &b) const
bool operator!=(TBoolType) const
AutoArray< X, Del > & operator=(const AutoArray< X, Del > &p)
Assignment operator.
static ssize_t Sub(const void *first, const void *second)
calculate offset inside object
const first_type & first() const
bool IsNull(void) const
Check if the object is unassigned.
element_type * operator->(void) const
Reference operator.
CFastBuffer(size_t buf_size)
void Execute(void) const override
X element_type
Define element type.
ERound
Whether to truncate/round a value.
TThis & operator=(const TThis &other)
static void * Add(void *object, ssize_t offset)
add offset to object reference (to get object's member)
element_type * x_Release(void) const
Release for const object.
unsigned int TSeqPos
Type for sequence locations and lengths.
void Swap(AutoPtr< X, Del > &a)
bool operator==(const TThis &id) const
bool operator<=(const TThis &id) const
CSafeFlags operator^(const CSafeFlags &b) const
constexpr size_t ArraySize(const Element(&)[Size])
unique_ptr< T, void(*)(T *)> c_unique_ptr
Template helpers for unique_ptr to work with resource allocating/deallocating C functions.
AutoArray(size_t size)
Construct the array using C++ new[] operator.
CStrictId< TKey, TStorage > TThis
TType m_EmbeddedBuffer[KEmbeddedSize]
#define ITERATE(Type, Var, Cont)
ITERATE macro to sequence through container elements.
const element_type & operator[](size_t pos) const
Array style dereference (returns value)
ENormalizePath
Whether to normalize a path.
pair_base_member< deleter_type, bool > m_Data
State info.
bool s_ITERATE_SameObject(const Type &obj1, const Type &obj2)
CSafeFlags & operator^=(const CSafeFlags &b)
CNullable(ENull=null)
Create an empty nullable.
underlying_type< enum_type >::type storage_type
bool operator>=(const TThis &id) const
int TSignedSeqPos
Type for signed sequence position.
element_type * get(void) const
Get pointer.
static X * Create(void)
Default create function.
AutoPtr(element_type *p=0)
Constructor.
TValue & SetValue(void)
Get a non-const reference to the value.
static void Delete(X *object)
Array delete function.
EFollowLinks
Whether to follow symbolic links (also known as shortcuts or aliases)
TType operator[](size_t pos) const
CStrictId< SStrictId_Gi, SStrictId_Gi::TId > TGi
static void Delete(X *object)
Default delete function.
TType * operator+(size_t offset)
unique_ptr< T, TDeleter > make_c_unique(T *p, TDeleter d)
Eliminates the necessity for specifying types of both allocated resource and deallocating C function.
TThis operator+(const TThis &id) const
SStrictId_Tax::TId TTaxId
Taxon id type.
Del deleter_type
Alias for template argument.
EInterruptOnSignal
Interrupt on signal mode.
CSafeFlags & operator&=(const CSafeFlags &b)
static void Delete(X *object)
C Language deallocation function.
#define DECLARE_OPERATOR_BOOL_PTR(Ptr)
Declaration of safe bool operator from pointer expression.
CSafeFlags< E > operator&(E a, CSafeFlags< E > b)
CSafeFlags< E > operator^(E a, CSafeFlags< E > b)
const TSeqPos kInvalidSeqPos
Define special value for invalid sequence position.
CNullable & operator=(TValue value)
Assign a value to the nullable.
ENullable
Whether a value is nullable.
element_type * get(void) const
Get pointer.
TThis operator-(void) const
list< unique_ptr< CAction_Base > > TActions
const second_type & second() const
void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)
virtual void Execute(void) const =0
element_type * release(void)
Release will release ownership of pointer to caller.
ESign
Signedness of a value.
element_type * release(void)
Release will release ownership of pointer to caller.
bool operator!=(const TThis &id) const
void reset(element_type *p=0)
Reset will delete the old pointer, set content to the new value, and assume the ownership upon the ne...
bool operator>(const TThis &id) const
const TValue & GetValue(void) const
Get a const reference to the current value.
@ eTriState_False
The value is equivalent to false/no.
@ eTriState_True
The value is equivalent to true/yes.
@ eTriState_Unknown
The value is indeterminate.
@ eRetriable_Unknown
It is unknown if the action can succeed if retried.
@ eRetriable_No
It makes no sense to retry the action.
@ eRetriable_Yes
It makes sense to try again.
@ eTrunc
Value must be truncated.
@ eRound
Value must be rounded.
@ eNormalizePath
Normalize a path.
@ eNotNormalizePath
Do not normalize a path.
@ eIgnoreLinks
Do not follow symbolic links.
@ eFollowLinks
Follow symbolic links.
@ eRestartOnSignal
Restart operation if interrupted by a signal.
@ eInterruptOnSignal
Cancel operation if interrupted by a signal.
@ eNotNullable
Value cannot be null.
@ eNullable
Value can be null.
@ eNegative
Value is negative.
@ ePositive
Value is positive.
@ eTakeOwnership
An object can take ownership of another.
@ eNoOwnership
No ownership is assumed.
#define ERR_POST(message)
Error posting with file, line number information but without error codes.
CFields operator|(CFields, CFields)
int32_t Int4
4-byte (32-bit) signed integer
uint32_t Uint4
4-byte (32-bit) unsigned integer
int64_t Int8
8-byte (64-bit) signed integer
uint64_t Uint8
8-byte (64-bit) unsigned integer
#define BEGIN_NCBI_NAMESPACE
#define END_NCBI_NAMESPACE
#define BEGIN_STD_NAMESPACE
#define END_STD_NAMESPACE
IO_PREFIX::ostream CNcbiOstream
Portable alias for ostream.
IO_PREFIX::istream CNcbiIstream
Portable alias for istream.
enum ENcbiSwitch ESwitch
Aux.
enum ENcbiOwnership EOwnership
Ownership relations between objects.
ENcbiOwnership
Ownership relations between objects.
#define NCBI_XNCBI_EXPORT
unsigned int
A callback function used to compare two keys in a database.
const struct ncbi::grid::netcache::search::fields::SIZE size
Magic spell ;-) needed for some weird compilers... very empiric.
const GenericPointer< typename T::ValueType > T2 value
NCBI C++ auxiliary debug macros.
std::istream & in(std::istream &in_, double &x_)
double r(size_t dimension_, const Int4 *score_, const double *prob_, double theta_)
static SLJIT_INLINE sljit_ins l(sljit_gpr r, sljit_s32 d, sljit_gpr x, sljit_gpr b)
Functor template for deleting array of objects.
Functor template for the C language deallocation function, free().
Functor template for allocating object.
Functor template for deleting object.
Key structs must always be defined - they are used in aliasinfo.cpp.