namespace Core

Overview

namespace Core {

// namespaces

namespace Core::Args;
namespace Core::Bluetooth;
namespace Core::CoreSpinLock;
namespace Core::Errors;
namespace Core::HTTPDefinitions;
namespace Core::HighPerformanceClock;
namespace Core::IO;
namespace Core::Java;
namespace Core::Meta;
namespace Core::Platform;
    namespace Core::Platform::CurrentProcess;
    namespace Core::Platform::CurrentThread;
    namespace Core::Platform::Debug;
    namespace Core::Platform::FileSystem;
    namespace Core::Platform::HighPerformanceClock;
    namespace Core::Platform::Network;
    namespace Core::Platform::PosixSocketSets;
    namespace Core::Platform::SSLTypes;
    namespace Core::Platform::SocketSets;
    namespace Core::Platform::StaticThreads;
    namespace Core::Platform::SystemClock;
        namespace Core::Platform::SystemClock::Helper;
    namespace Core::Platform::TLS;
namespace Core::Plugins;
namespace Core::Portable;
    namespace Core::Portable::AuthorizationPolicy;
    namespace Core::Portable::BMF;
    namespace Core::Portable::BitmapFileFormat;
    namespace Core::Portable::Colors;
    namespace Core::Portable::ComponentFlags;
    namespace Core::Portable::HTTP;
    namespace Core::Portable::Logging;
    namespace Core::Portable::ResourceAttributes;
    namespace Core::Portable::ThreadAwareCompression;
    namespace Core::Portable::ViewAttributes;
    namespace Core::Portable::ViewClasses;
namespace Core::Security;
    namespace Core::Security::JOSE;
namespace Core::Skin;
    namespace Core::Skin::FileNames;
    namespace Core::Skin::KeyboardCapitalization;
    namespace Core::Skin::KeyboardLayout;
    namespace Core::Skin::ResourceAttributes;
    namespace Core::Skin::ViewAttributes;
    namespace Core::Skin::ViewClasses;
namespace Core::Sockets;
    namespace Core::Sockets::Discovery;
    namespace Core::Sockets::Network;
    namespace Core::Sockets::SSLTypes;
    namespace Core::Sockets::SocketTypes;
        namespace Core::Sockets::SocketTypes::SocketOption;
namespace Core::SystemClock;
namespace Core::Test;
namespace Core::Text;
    namespace Core::Text::Json;
    namespace Core::Text::UTFCodec;
    namespace Core::Text::UTFFunctions;
namespace Core::Threads;
    namespace Core::Threads::CurrentProcess;
    namespace Core::Threads::CurrentThread;
    namespace Core::Threads::TLS;
    namespace Core::Threads::Threading;
namespace Core::URLEncoding;
namespace Core::Usb;
namespace Core::Zip;

// typedefs

typedef RecognizerPool<SwipeRecognizer, 16> SwipeRecognizerPool;
typedef PooledRecognizer<SwipeRecognizer, SwipeRecognizerPool, 16> PooledSwipeRecognizer;
typedef RecognizerPool<ZoomRecognizer, 16> ZoomRecognizerPool;
typedef PooledRecognizer<ZoomRecognizer, ZoomRecognizerPool, 16> PooledZoomRecognizer;
typedef RecognizerPool<RotateRecognizer, 16> RotateRecognizerPool;
typedef PooledRecognizer<RotateRecognizer, RotateRecognizerPool, 16> PooledRotateRecognizer;
typedef RecognizerPool<LongPressRecognizer, 16> LongPressRecognizerPool;
typedef PooledRecognizer<LongPressRecognizer, LongPressRecognizerPool, 16> PooledLongPressRecognizer;
typedef RecognizerPool<SingleTapRecognizer, 16> SingleTapRecognizerPool;
typedef PooledRecognizer<SingleTapRecognizer, SingleTapRecognizerPool, 16> PooledSingleTapRecognizer;
typedef RecognizerPool<DoubleTapRecognizer, 16> DoubleTapRecognizerPool;
typedef PooledRecognizer<DoubleTapRecognizer, DoubleTapRecognizerPool, 16> PooledDoubleTapRecognizer;
typedef int32 FourCharID;
typedef FourCharID PropertyType;
typedef FourCharID InterfaceID;
typedef int ErrorCode;
typedef signed char int8;
typedef unsigned char uint8;
typedef short int16;
typedef unsigned short uint16;
typedef int int32;
typedef unsigned int uint32;
typedef long long int64;
typedef unsigned long long uint64;
typedef int32 IntPtr;
typedef uint32 UIntPtr;
typedef int64 int40;
typedef int64 abs_time;
typedef float float32;
typedef double float64;
typedef uint8 tbool;
typedef void* ModuleRef;
typedef uint16 uchar;
typedef uint32 uchar32;
typedef const char* CStringPtr;
typedef const uchar* UStringPtr;
typedef Core::int32 ExitCode;
typedef Core::int32 Severity;
typedef const Alignment& AlignmentRef;
typedef uint8 Pixel;
typedef const Color& ColorRef;
typedef const ColorF& ColorFRef;
typedef UIntPtr TouchID;
typedef int Coord;
typedef float CoordF;
typedef TPoint<Coord> Point;
typedef const Point& PointRef;
typedef TPoint<CoordF> PointF;
typedef const PointF& PointFRef;
typedef TRect<Coord> Rect;
typedef const Rect& RectRef;
typedef TRect<CoordF> RectF;
typedef const RectF& RectFRef;

// enums

enum CoordLimits;
enum ExitCodeEnum;
enum JoypadButton;
enum PointerValue;
enum SeverityEnum;
enum UIPropertyTypes;

// structs

struct Alignment;
struct Allocator;
struct AttributeHandler;
struct BitmapData;
struct Color;
struct ColorF;
struct ColorHSL;
struct ColorHSV;
struct ColorProperty;
struct DebugInfo;
struct DebugInfoList;

template <int size>
struct DebugInfoTable;

template <class T>
struct Deleter;

struct EnumInfo;
struct GestureEventArgs;
struct ICoreView;
struct IGameBitmapRenderer;
struct IGameCore;
struct IGameEnvironment;
struct IGameLibrary;
struct IProfiler;
struct IProfilingData;
struct IPropertyHandler;
struct InterfaceProperty;
struct InterpolatorClass;

template <typename TKey, typename TValue>
struct KeyValue;

struct Property;
struct RGBA;

template <int kFlag, typename T = int>
struct ScopedFlag;

template <typename T>
struct ScopedVar;

struct StringResult;

template <typename Type>
struct TPoint;

template <typename Type>
struct TRect;

struct TouchInfo;
struct UIDBytes;

template <class T>
struct VectorDeleter;

struct Version;
struct ViewClassProperty;
struct ViewNameProperty;
struct ViewSizeProperty;
struct ViewSourceProperty;

template <int64 a, int64 b>
struct static_max;

template <int64 a, int64 b>
struct static_min;

template <int64 base>
struct static_power<base, 0>;

template <int64 base, int exponent>
struct static_power;

// classes

class AtomicStack;
class AtomicStackLocked;
class BMPHandler;
class BitSet;
class BitmapPrimitives;
class BitmapPrimitives16;
class BitmapPrimitives32;
class BitmapPrimitivesMonochrome;

template <int maxSize>
class CStringBuffer;

class CStringClassifier;
class CStringFunctions;
class CStringTokenizer;
class CStringTokenizerInplace;

template <typename T>
class CStringTraits;

template <typename TKey, typename TValue>
class ConstMap;

class ConstString;

template <class T>
class ConstVector;

class Date;
class DateTime;

template <class T>
class Deque;

class DoubleTapRecognizer;

template <class T>
class FixedDeque;

template <class T, int maxElements>
class FixedSizeVector;

class FloatFormatter;
class Formatter;
class FormatterRegistry;
class FormatterRegistryList;
class GestureInfo;
class GestureRecognition;

template <class TKey, class TValue>
class HashMap;

template <class TKey, class TValue>
class HashMapIterator;

class HeapAllocator;
class IDSet;

template <class T>
class InitializerList;

class IntFormatter;
class Interpolator;
class InterpolatorClassList;
class InterpolatorFactory;
class LeadingZeroFormatter;
class LinearInterpolator;
class LinearReverseInterpolator;

template <class T>
class LinkedList;

template <class T>
class ListIterator;

template <class T>
class ListLink;

class LongPressRecognizer;

template <class AtomicPolicy>
class MemoryPool;

template <typename T>
class MutableCStringTraits;

template <class T, class ResizePolicy>
class MutableVector;

template <class T>
class ObserverList;

class PNGHandler;
class PercentFormatter;
class PercentRangeFormatter;

template <
    typename T,
    uint32 numBlocks,
    uint32 blockSize = 1,
    uint32 alignment = 1
>
class PoolAllocator;

template <typename T, uint32 numBlocks, uint32 blockSize = 1>
class PoolAllocatorExtern;

template <class T, class Pool>
class PooledObject;

template <class T, class Pool, int size>
class PooledRecognizer;

class RangeFormatter;

template <class Container, class Iterator, class Element>
class RangeIterator;

template <class T, int size>
class RecognizerPool;

class RotateRecognizer;
class SegmentInterpolator;
class SingleTapRecognizer;
class StringListFormatter;
class SwipeRecognizer;
class Time;

template <bool enabled>
class TimedInterval;

template <>
class TimedInterval<true>;

template <class T>
class TreeSet;

template <class T>
class TreeSetIterator;

template <class T>
class Vector;

template <class T>
class VectorIterator;

class WinDeviceNotificationHandler;
class ZoomInterpolator;
class ZoomRecognizer;

// global variables

static FixedSizeVector<PooledSwipeRecognizer, 16> SwipeRecognizerPoolinstance;
static FixedSizeVector<PooledZoomRecognizer, 16> ZoomRecognizerPoolinstance;
static FixedSizeVector<PooledRotateRecognizer, 16> RotateRecognizerPoolinstance;
static FixedSizeVector<PooledLongPressRecognizer, 16> LongPressRecognizerPoolinstance;
static FixedSizeVector<PooledSingleTapRecognizer, 16> SingleTapRecognizerPoolinstance;
static FixedSizeVector<PooledDoubleTapRecognizer, 16> DoubleTapRecognizerPoolinstance;
static const int kCoordLimitsMaxCoord = 0x0fff000;
static const int kCoordLimitsMinCoord = -kCoordLimitsMaxCoord;
static const int kAlignmentHCenter = 0x00;
static const int kAlignmentLeft = 0x01;
static const int kAlignmentRight = 0x02;
static const int kAlignmentHMask = 0x0F;
static const int kAlignmentVCenter = 0x00;
static const int kAlignmentTop = 0x10;
static const int kAlignmentBottom = 0x20;
static const int kAlignmentVMask = 0xF0;
static const int kAlignmentCenter = kAlignmentHCenter|kAlignmentVCenter;
static const int kAlignmentLeftCenter = kAlignmentLeft|kAlignmentVCenter;
static const int kAlignmentRightCenter = kAlignmentRight|kAlignmentVCenter;
static const int kAlignmentLeftTop = kAlignmentLeft|kAlignmentTop;
static const int kAlignmentRightTop = kAlignmentRight|kAlignmentTop;
static const int kAlignmentLeftBottom = kAlignmentLeft|kAlignmentBottom;
static const int kAlignmentRightBottom = kAlignmentRight|kAlignmentBottom;
jstring handshake write;
jstring handshake jbyteArray;
jstring handshake int JLjava lang String;

// global functions

DECLARE_JNI_CLASS(SSLChannel, CORE_CLASS_PREFIX "SSLChannel");
jstring DECLARE_JNI_METHOD(void, close);
jstring handshake DECLARE_JNI_METHOD(int, read, jbyteArray, int);
jstring handshake int END_DECLARE_JNI_CLASS(SSLChannel);
V DEFINE_JNI_METHOD(close, "()V");
V V DEFINE_JNI_METHOD(read, "([BI)I");

template <typename T>
T byte_swap(T value);

template <typename T>
bool is_power2(T x);

template <typename T>
T get_min(T a, T b);

template <typename T>
T get_max(T a, T b);

template <typename T>
T get_abs(const T v);

template <typename T>
T bound(const T v, const T vmin = 0, const T vmax = 1);

template <typename T>
T sign(const T v);

template <typename float>
int round(float v);

template <typename T>
void swap_vars(T& a, T& b);

template <class Interface>
Interface* GetInterface(
    IPropertyHandler* handler,
    InterfaceID iid
);

template <class Interface>
Interface* GetInterface(IPropertyHandler* handler);

template <class Class, class Interface>
bool ImplementGetInterface(
    Class* This,
    Property& value,
    InterfaceID iid
);

template <class Class, class Interface>
bool ImplementGetInterface(
    Class* This,
    Property& value
);

void DebugPrint(CStringPtr string);
void DebugPrintf(CStringPtr format, ...);
int coreTest(int argc, char* argv[]);

} // namespace Core

Detailed Documentation

Typedefs

typedef int32 FourCharID

Four-character identifier.

typedef FourCharID PropertyType

Property type.

typedef FourCharID InterfaceID

Interface identifier.

typedef int ErrorCode

Error code.

typedef signed char int8

8 Bit integer (signed)

typedef unsigned char uint8

8 Bit integer (unsigned)

typedef short int16

16 Bit integer (signed)

typedef unsigned short uint16

16 Bit integer (unsigned)

typedef int int32

32 Bit integer (signed)

typedef unsigned int uint32

32 Bit integer (unsigned)

typedef int32 IntPtr

integer pointer (32 Bit)

typedef uint32 UIntPtr

unsigned integer pointer (32 Bit)

typedef float float32

32 Bit floating-point type.

typedef double float64

64 Bit floating-point type.

typedef uint8 tbool

Compiler-independent boolean type.

typedef void* ModuleRef

Platform-specific Module Reference.

typedef uint32 uchar32

32 Bit Unicode character (UTF-32)

typedef const char* CStringPtr

Constant C-string pointer.

typedef const uchar* UStringPtr

Constant 16 Bit Unicode string pointer (UTF-16).

typedef Core::int32 ExitCode

Process exit code.

typedef Core::int32 Severity

Logging severity.

typedef const Alignment& AlignmentRef

Alignment reference type.

typedef uint8 Pixel

Part of 24 Bit RGB pixel.

typedef const Color& ColorRef

Color reference type (8 bit).

typedef const ColorF& ColorFRef

Color reference type (floating point).

typedef UIntPtr TouchID

ID of one touch.

typedef int Coord

Integer coordinate.

typedef float CoordF

Float coordinate.

typedef TPoint<Coord> Point

Point with integer coordinates.

typedef TPoint<CoordF> PointF

Point with float coordinates.

typedef TRect<Coord> Rect

Rectangle with integer coordinates.

typedef TRect<CoordF> RectF

Rectangle with float coordinates.

Global Variables

static const int kCoordLimitsMaxCoord = 0x0fff000

max. coordinate value

static const int kCoordLimitsMinCoord = -kCoordLimitsMaxCoord

min. coordinate value

static const int kAlignmentHCenter = 0x00

center horizontally

static const int kAlignmentLeft = 0x01

align left

static const int kAlignmentRight = 0x02

align right

static const int kAlignmentVCenter = 0x00

center vertically

static const int kAlignmentTop = 0x10

align top

static const int kAlignmentBottom = 0x20

align bottom

Global Functions

template <typename T>
bool is_power2(T x)

Checks if the given integer is a power of 2.

http://graphics.stanford.edu/~seander/bithacks.html#DetermineIfPowerOf2

template <typename T>
T get_min(T a, T b)

Get minimum of two values.

template <typename T>
T get_max(T a, T b)

Get maximum of two values.

template <typename T>
T get_abs(const T v)

Get the absolute value.

template <typename T>
T bound(const T v, const T vmin = 0, const T vmax = 1)

Bound value between given minimum and maximum.

template <typename T>
T sign(const T v)

Get the signum of a value.

template <typename float>
int round(float v)

Round to the given floating point value to integer.

template <typename T>
void swap_vars(T& a, T& b)

Swap the contents of two variables.

template <class Interface>
Interface* GetInterface(
    IPropertyHandler* handler,
    InterfaceID iid
)

Helper to get additional interface.

template <class Class, class Interface>
bool ImplementGetInterface(
    Class* This,
    Property& value,
    InterfaceID iid
)

Helper to implement query for interface.