alternative Standard Libary  0.29.8
Klassen | Öffentliche Typen | Öffentliche, statische Methoden | Aufstellung aller Elemente
std::Sys Klassenreferenz

#include <common.hpp>

Klassen

struct  mutex_struct
 
struct  spinlock_struct
 

Öffentliche Typen

enum  mutex_init_t { mutex_init_t::Normal, mutex_init_t::Recursive, mutex_init_t::ErrorCheak, mutex_init_t::Default = mutex_init_t::Normal }
 
typedef struct std::Sys::mutex_struct mutex_type
 
typedef struct std::Sys::spinlock_struct spinlk_type
 

Öffentliche, statische Methoden

static void MemCpy (void *to, const void *from, size_t bytes)
 
static void MemMove (void *to, const void *from, size_t bytes)
 
static void MemSet (void *buf, unsigned char value, size_t bytes)
 
static void wMemCpy (void *to, const void *from, size_t bytes)
 
static void wMemMove (void *to, const void *from, size_t bytes)
 
static void wMemSet (void *buf, unsigned char value, size_t bytes)
 
static int vsnPrintf (char *buffer, size_t count, const char *format, va_list argptr)
 
static int fPrintf (void *file, const char *str)
 
static void * fOpen (const char *file, const char *fmt)
 
static void fClose (void *file)
 
static int fTell (void *file)
 
static int fPutc (int c, void *file)
 
static int fPuts (const char *str, void *file)
 
static int fGetc (void *file)
 
static int fSeek (void *file, int off, int org)
 
static int fRead (void *data, const int count, const int size, void *file)
 
static int fWrite (void *data, const int count, const int size, void *file)
 
static int fFlush (void *file)
 
static int fEOF (void *file)
 
static int fError (void *file)
 
static bool fIsFile (const char *file)
 
static void * mAlloc (size_t size)
 
static void * mReAlloc (void *old, size_t newSize)
 
static void mFree (void *mem)
 
template<typename T >
static T * mAllocE (int elements)
 
static int mutexInit (mutex_type *mutex, mutex_init_t type=mutex_init_t::Normal, bool shared=false, bool robust=false)
 
static int mutexDestroy (mutex_type *mutex)
 
static int mutexLock (mutex_type *mutex)
 
static int mutexUnLock (mutex_type *mutex)
 
static int mutexTryLock (mutex_type *mutex)
 
static int spinlockInit (spinlk_type *mutex, const void *attr)
 
static int spinlockDestroy (spinlk_type *mutex)
 
static int spinlockLock (spinlk_type *mutex)
 
static int spinlockUnLock (spinlk_type *mutex)
 
static int spinlockTryLock (spinlk_type *mutex)
 
static uint64_t pTotalMem ()
 

Ausführliche Beschreibung

Dokumentation der benutzerdefinierten Datentypen

◆ mutex_type

typedef struct std::Sys::mutex_struct std::Sys::mutex_type

◆ spinlk_type

typedef struct std::Sys::spinlock_struct std::Sys::spinlk_type

Dokumentation der Aufzählungstypen

◆ mutex_init_t

enum std::Sys::mutex_init_t
strong
Aufzählungswerte
Normal 
Recursive 
ErrorCheak 
Default 
95  {
96  Normal,
97  Recursive,
98  ErrorCheak,
99  Default = mutex_init_t::Normal,
100  };

Dokumentation der Elementfunktionen

◆ fClose()

void std::Sys::fClose ( void *  file)
static
71  {
72  fclose((FILE*)file);
73  }

◆ fEOF()

int std::Sys::fEOF ( void *  file)
static
101  {
102  return feof((FILE*)file);
103  }

◆ fError()

int std::Sys::fError ( void *  file)
static
104  {
105  return ferror((FILE*)file);
106  }

◆ fFlush()

int std::Sys::fFlush ( void *  file)
static
98  {
99  return fflush((FILE*)file);
100  }

◆ fGetc()

int std::Sys::fGetc ( void *  file)
static
83  {
84  return fgetc((FILE*)file);
85  }

◆ fIsFile()

bool std::Sys::fIsFile ( const char *  file)
static
107  {
108  struct stat buffer;
109  return (stat (file, &buffer) == 0);
110  }

◆ fOpen()

void * std::Sys::fOpen ( const char *  file,
const char *  fmt 
)
static
68  {
69  return fopen(file, fmt);
70  }

◆ fPrintf()

int std::Sys::fPrintf ( void *  file,
const char *  str 
)
static
86  {
87  return fprintf((FILE*)file, str);
88  }
str
std::string str(T begin, T end)
Definition: utils.hpp:39

◆ fPutc()

int std::Sys::fPutc ( int  c,
void *  file 
)
static
77  {
78  return fputc(c, (FILE*)file);
79  }

◆ fPuts()

int std::Sys::fPuts ( const char *  str,
void *  file 
)
static
80  {
81  return fputs(str, (FILE*)file);
82  }
str
std::string str(T begin, T end)
Definition: utils.hpp:39

◆ fRead()

int std::Sys::fRead ( void *  data,
const int  count,
const int  size,
void *  file 
)
static
92  {
93  return fread(data, count, size, (FILE*)file);
94  }

◆ fSeek()

int std::Sys::fSeek ( void *  file,
int  off,
int  org 
)
static
89  {
90  return fseek((FILE*)file, off, org);
91  }

◆ fTell()

int std::Sys::fTell ( void *  file)
static
74  {
75  return ftell((FILE*)file);
76  }

◆ fWrite()

int std::Sys::fWrite ( void *  data,
const int  count,
const int  size,
void *  file 
)
static
95  {
96  return fwrite(data, count, size, (FILE*)file);
97  }

◆ mAlloc()

void * std::Sys::mAlloc ( size_t  size)
static
111  {
112  return malloc(size);
113  }

◆ mAllocE()

template<typename T >
static T* std::Sys::mAllocE ( int  elements)
inlinestatic
91  {
92  return (T*)Sys::mAlloc(sizeof(T) * elements);
93  }
std::Sys::mAlloc
static void * mAlloc(size_t size)
Definition: PLATFORM.cpp:111

◆ MemCpy()

void std::Sys::MemCpy ( void *  to,
const void *  from,
size_t  bytes 
)
static
40  {
41  memcpy(to, from, bytes);
42  }

◆ MemMove()

void std::Sys::MemMove ( void *  to,
const void *  from,
size_t  bytes 
)
static
44  {
45  memmove(to, from, bytes);
46  }

◆ MemSet()

void std::Sys::MemSet ( void *  buf,
unsigned char  value,
size_t  bytes 
)
static
48  {
49  memset(buf, value, bytes);
50  }

◆ mFree()

void std::Sys::mFree ( void *  mem)
static
117  {
118  free(mem);
119  }

◆ mReAlloc()

void * std::Sys::mReAlloc ( void *  old,
size_t  newSize 
)
static
114  {
115  return realloc(old, newSize);
116  }

◆ mutexDestroy()

int std::Sys::mutexDestroy ( mutex_type *  mutex)
static
141  {
142  return pthread_mutex_destroy( (pthread_mutex_t*)&mutex );
143  }

◆ mutexInit()

int std::Sys::mutexInit ( mutex_type *  mutex,
mutex_init_t  type = mutex_init_t::Normal,
bool  shared = false,
bool  robust = false 
)
static
122  {
123  pthread_mutexattr_t attr;
124  pthread_mutexattr_init(&attr);
125  pthread_mutexattr_setpshared(&attr,
126  (shared ? PTHREAD_PROCESS_SHARED : PTHREAD_PROCESS_PRIVATE) );
127  int t = PTHREAD_MUTEX_NORMAL;
128  if(type == mutex_init_t::Recursive)
129  t = PTHREAD_MUTEX_RECURSIVE;
130  else if(type == mutex_init_t::ErrorCheak)
131  t = PTHREAD_MUTEX_ERRORCHECK;
132 
133  pthread_mutexattr_setrobust(&attr, (robust ? PTHREAD_MUTEX_ROBUST : PTHREAD_MUTEX_STALLED));
134  pthread_mutexattr_settype(&attr, t);
135 
136  int exit = pthread_mutex_init( (pthread_mutex_t*)&mutex, &attr );
137  pthread_mutexattr_destroy(&attr);
138  return exit;
139  }

◆ mutexLock()

int std::Sys::mutexLock ( mutex_type *  mutex)
static
144  {
145  return pthread_mutex_lock( (pthread_mutex_t*)&mutex );
146  }

◆ mutexTryLock()

int std::Sys::mutexTryLock ( mutex_type *  mutex)
static
150  {
151  return pthread_mutex_trylock( (pthread_mutex_t*)&mutex );
152  }

◆ mutexUnLock()

int std::Sys::mutexUnLock ( mutex_type *  mutex)
static
147  {
148  return pthread_mutex_unlock( (pthread_mutex_t*)&mutex );
149  }

◆ pTotalMem()

uint64_t std::Sys::pTotalMem ( )
static
169  {
170  return 536870912;
171  }

◆ spinlockDestroy()

int std::Sys::spinlockDestroy ( spinlk_type *  mutex)
static
157  {
158  return pthread_spin_destroy( (pthread_spinlock_t*)&spin );
159  }

◆ spinlockInit()

int std::Sys::spinlockInit ( spinlk_type *  mutex,
const void *  attr 
)
static
154  {
155  return pthread_spin_init( (pthread_spinlock_t*)&spin, 0);
156  }

◆ spinlockLock()

int std::Sys::spinlockLock ( spinlk_type *  mutex)
static
160  {
161  return pthread_spin_lock( (pthread_spinlock_t*)&spin );
162  }

◆ spinlockTryLock()

int std::Sys::spinlockTryLock ( spinlk_type *  mutex)
static
166  {
167  return pthread_spin_trylock( (pthread_spinlock_t*)&spin );
168  }

◆ spinlockUnLock()

int std::Sys::spinlockUnLock ( spinlk_type *  mutex)
static
163  {
164  return pthread_spin_unlock( (pthread_spinlock_t*)&spin );
165  }

◆ vsnPrintf()

int std::Sys::vsnPrintf ( char *  buffer,
size_t  count,
const char *  format,
va_list  argptr 
)
static
64  {
65  return _vsnprintf(buffer, count, format, argptr);
66  }

◆ wMemCpy()

void std::Sys::wMemCpy ( void *  to,
const void *  from,
size_t  bytes 
)
static
53  {
54  wmemcpy((wchar_t*)to, (wchar_t*)from, bytes);
55  }

◆ wMemMove()

void std::Sys::wMemMove ( void *  to,
const void *  from,
size_t  bytes 
)
static
57  {
58  wmemmove((wchar_t*)to, (wchar_t*)from, bytes);
59  }

◆ wMemSet()

void std::Sys::wMemSet ( void *  buf,
unsigned char  value,
size_t  bytes 
)
static
61  {
62  wmemset((wchar_t*)buf, value, bytes);
63  }
Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Dateien: