namespace Core

Overview

namespace Core {

// namespaces

namespace Core::Args;
namespace Core::Bluetooth;
namespace Core::Errors;
namespace Core::HTTPDefinitions;
namespace Core::IO;
namespace Core::MathUtils;
namespace Core::Plugins;
namespace Core::Security;
    namespace Core::Security::JOSE;
namespace Core::Sockets;
    namespace Core::Sockets::SocketTypes;
        namespace Core::Sockets::SocketTypes::SocketOption;
namespace Core::SpeakerDef;
namespace Core::Threads;
    namespace Core::Threads::Threading;
namespace Core::URLEncoding;
namespace Core::Usb;

// typedefs

typedef uint32 SilenceBitField;
typedef int64 TSamples;
typedef double TSeconds;
typedef double SampleRate;
typedef StaticAudioMeterData <kMaxAudioMeterChannels> AudioMeterDataMax;
typedef uint32 SpeakerID;
typedef uint32 SpeakerBitField;
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 AudioFloatType;
enum AudioFormatType;
enum AudioSampleType;
enum BitmapPixelFormat;
enum CoordLimits;
enum ExitCodeEnum;
enum JoypadButton;
enum PointerValue;
enum SeverityEnum;
enum UIPropertyTypes;

// structs

struct Alignment;
struct Allocator;
struct AudioData;
struct AudioDataSpan;
struct AudioIOData;
struct AudioMeterData;
struct BitmapData;
struct Color;
struct ColorF;
struct ColorHSL;
struct ColorHSV;
struct ColorProperty;

template <class T>
struct Deleter;

struct EnumInfo;
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;

template <int kNumChannels, int kNumSamples, typename Float = float32>
struct StaticAudioData;

template <
    int kNumInputs,
    int kNumOutputs,
    int kMaxChannels = kMaxAudioStreamChannels
>
struct StaticAudioIOData;

template <int kMaxChannels>
struct StaticAudioMeterData;

template <
    typename float,
    int kStreamCount,
    int kSampleCount,
    int kChannelCount = kMaxAudioStreamChannels
>
struct StaticAudioStreamBuffers;

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 BitSet;

template <int maxSize>
class CStringBuffer;

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

template <typename T>
class CStringTraits;

template <
    typename TKey,
    typename TValue,
    typename TEntries = ConstVector <KeyValue <TKey, TValue>>
>
class ConstMap;

class ConstString;

template <class T>
class ConstVector;

class Date;
class DateTime;

template <class T>
class Deque;

template <class T>
class FixedDeque;

template <class T, int maxElements>
class FixedSizeVector;

class FloatFormatter;
class Formatter;
class FormatterRegistry;
class FormatterRegistryList;

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;

template <typename TKey, typename TValue>
class Map;

template <class AtomicPolicy>
class MemoryPool;

template <typename T>
class MutableCStringTraits;

template <class T, class ResizePolicy>
class MutableVector;

template <class T>
class ObserverList;

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;

class RangeFormatter;

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

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

class SegmentInterpolator;
class StringListFormatter;
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 ZoomInterpolator;

// global variables

static constexpr int kMaxAudioStreamChannels = 32;
static constexpr uint32 kAudioAllChannelsMask = 0xFFFFFFFF;
static constexpr int kMaxAudioMeterChannels = 16;

// global functions

int getAudioByteSize (int numSamples, AudioFloatType type);

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
);

} // namespace Core

Detailed Documentation

Typedefs

typedef uint32 SilenceBitField

Bit field for audio stream silence (max.

32 channels).

typedef int64 TSamples

Number or position of audio samples.

typedef double TSeconds

Time represented in seconds.

typedef double SampleRate

Sample rate in Hz.

typedef uint32 SpeakerID

Speaker type.

typedef uint32 SpeakerBitField

Bit field of speakers.

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 constexpr int kMaxAudioStreamChannels = 32

Maximum number of channels per audio stream.

static constexpr uint32 kAudioAllChannelsMask = 0xFFFFFFFF

Bitmask for all audio stream channels.

Global Functions

int getAudioByteSize (int numSamples, AudioFloatType type)

Get size of audio data in Bytes.

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.