Datasets:

ssuresh

/

HPC_corpus_sub

like 0

Chocanto

arduino-geothermie

server/src/DateTime.cpp

DateTime::add

DateTime DateTime::add(const DateTimeDuration& dur) const { if (dur.isNegative()) { return subtract(dur.days(), dur.hours(), dur.minutes(), dur.seconds(), dur.milliseconds()); } else { return add(dur.days(), dur.hours(), dur.minutes(), dur.seconds(), dur.milliseconds()); } }

DateTimeDuration::DateTimeDuration(unsigned int _days, unsigned int _hours, unsigned int _minutes, unsigned int _seconds, unsigned int _milliseconds, bool _is_negative); DateTimeDuration::DateTimeDuration(const DateTimeDuration& dur); int DateTimeDuration::compare(const DateTimeDuration& rhs); DateTimeDuration& DateTimeDuration::operator=(const DateTimeDuration& rhs); bool DateTimeDuration::operator==(const DateTimeDuration& rhs); bool DateTimeDuration::operator!=(const DateTimeDuration& rhs); bool DateTimeDuration::operator<(const DateTimeDuration& rhs); bool DateTimeDuration::operator<=(const DateTimeDuration& rhs); bool DateTimeDuration::operator>(const DateTimeDuration& rhs); bool DateTimeDuration::operator>=(const DateTimeDuration& rhs); void DateTimeDuration::setDateTimeDuration(unsigned int _days, unsigned int _hours, unsigned int _minutes, unsigned int _seconds, unsigned int _milliseconds, bool _is_negative); bool DateTimeDuration::isZero(); unsigned int DateTimeDuration::days(); unsigned int DateTimeDuration::days(unsigned int _days); unsigned int DateTimeDuration::hours(); unsigned int DateTimeDuration::hours(unsigned int _hours); unsigned int DateTimeDuration::minutes(); unsigned int DateTimeDuration::minutes(unsigned int _minutes); unsigned int DateTimeDuration::seconds(); unsigned int DateTimeDuration::seconds(unsigned int _seconds); unsigned int DateTimeDuration::milliseconds(); unsigned int DateTimeDuration::milliseconds(unsigned int _milliseconds); bool DateTimeDuration::isNegative(); bool DateTimeDuration::isNegative(bool _is_negative); ostream& operator<<(ostream& os, const DateTimeDuration& dtd); DateTime::DateTime(unsigned int _year, unsigned int _month, unsigned int _day, unsigned int _hour, unsigned int _minute, unsigned int _second, unsigned int _millisecond); DateTime::DateTime(const DateTime& dt); DateTime::DateTime(const tm& time_struct); DateTime::DateTime(const time_t& time); int DateTime::compare(const DateTime& rhs); DateTime& DateTime::operator=(const DateTime& rhs); bool DateTime::operator==(const DateTime& rhs); bool DateTime::operator!=(const DateTime& rhs); bool DateTime::operator<(const DateTime& rhs); bool DateTime::operator<=(const DateTime& rhs); bool DateTime::operator>(const DateTime& rhs); bool DateTime::operator>=(const DateTime& rhs); void DateTime::setDate(unsigned int _year, unsigned int _month, unsigned int _day); void DateTime::setTime(unsigned int _hour, unsigned int _minute, unsigned int _second, unsigned int _millisecond); void DateTime::setDateTime(unsigned int _year, unsigned int _month, unsigned int _day, unsigned int _hour, unsigned int _minute, unsigned int _second, unsigned int _millisecond); unsigned int DateTime::year(); unsigned int DateTime::year(unsigned int _year); unsigned int DateTime::month(); unsigned int DateTime::month(unsigned int _month); unsigned int DateTime::day(); unsigned int DateTime::day(unsigned int _day); unsigned int DateTime::dayOfYear(); unsigned int DateTime::dayOfYear(unsigned int _dayOfYear); unsigned int DateTime::hour(); unsigned int DateTime::hour(unsigned int _hour); unsigned int DateTime::minute(); unsigned int DateTime::minute(unsigned int _minute); unsigned int DateTime::second(); unsigned int DateTime::second(unsigned int _second); unsigned int DateTime::millisecond(); unsigned int DateTime::millisecond(unsigned int _millisecond); DateTime DateTime::subtractDays(unsigned int _days); DateTime DateTime::addDays(unsigned int _days); DateTime DateTime::subtractHours(unsigned int _hours); DateTime DateTime::addHours(unsigned int _hours); DateTime DateTime::subtractMinutes(unsigned int _minutes); DateTime DateTime::addMinutes(unsigned int _minutes); DateTime DateTime::subtractSeconds(unsigned int _seconds); DateTime DateTime::addSeconds(unsigned int _seconds); DateTime DateTime::subtractMilliseconds(unsigned int _milliseconds); DateTime DateTime::addMilliseconds(unsigned int _milliseconds); DateTime DateTime::subtract(unsigned int _days, unsigned int _hours, unsigned int _minutes, unsigned int _seconds, unsigned int _milliseconds); DateTime DateTime::add(unsigned int _days, unsigned int _hours, unsigned int _minutes, unsigned int _seconds, unsigned int _milliseconds); DateTime DateTime::subtract(const DateTimeDuration& dur); DateTimeDuration DateTime::timeBetween(const DateTime& rhs); bool DateTime::isLeapYear(unsigned int _year); bool DateTime::validDate(unsigned int _year, unsigned int _month, unsigned int _day); unsigned short DateTime::daysInYear(unsigned int _year); unsigned short DateTime::daysInMonth(unsigned int _year, unsigned int _month); unsigned short DateTime::getDayOfYear(unsigned int _year, unsigned int _month, unsigned int _day); DateTime DateTime::getReverseDayOfYear(unsigned int _year, unsigned int _dayOfYear); time_t DateTime::mktime(); double DateTime::difftime(const DateTime& rhs); DateTime DateTime::now(); DateTime DateTime::now_utc(); ostream& operator<<(ostream& os, const DateTime& ddt);

04c1a7f260c96daaeacf51fe94c0e3961557086e0c3bba1ff7b2373325bf05da

JianpingZeng

xcc

samples/Juliet/testcases/CWE126_Buffer_Overread/s02/CWE126_Buffer_Overread__new_wchar_t_loop_11.cpp

goodG2B1

static void goodG2B1() { wchar_t * data; data = NULL; if(globalReturnsFalse()) { printLine("Benign, fixed string"); } else { data = new wchar_t[100]; wmemset(data, L'A', 100-1); data[100-1] = L'\0'; } { size_t i, destLen; wchar_t dest[100]; wmemset(dest, L'C', 100-1); dest[100-1] = L'\0'; destLen = wcslen(dest); for (i = 0; i < destLen; i++) { dest[i] = data[i]; } dest[100-1] = L'\0'; printWLine(dest); delete [] data; } }

void bad(); static void goodG2B2(); void good(); int main(int argc, char * argv[]);

12ac49ddb48ba5a3fef3304624481a0e848279696dfed05243a9c882008d3ada

abergmeier

jedi_academy

codemp/win32/win_qgl_dx8.cpp

_terminateDrawPacket

inline static DWORD* _terminateDrawPacket(DWORD* packet) { return packet; }

void BeginSkinTextures( void ); void EndSkinTextures( void ); static int getTexMemSize(IDirect3DTexture8* mipmap); static void _d3d_check(HRESULT err, const char* func); static bool surfaceToBMP(LPDIRECT3DDEVICE8 pd3dDevice, LPDIRECT3DSURFACE8 lpSurface, const char *fname); static void _fixupScreenCoords(GLint& x, GLint& y, GLsizei& width, GLsizei& height); static D3DCMPFUNC _convertCompare(GLenum func); static D3DBLEND _convertBlendFactor(GLenum factor); static D3DPRIMITIVETYPE _convertPrimMode(GLenum mode); static void _updateDrawStride(GLint normal, GLint tex0, GLint tex1); static void _updateShader(bool normal, bool tex0, bool tex1); static glwstate_t::TextureInfo* _getCurrentTexture(int stage); static void _updateTextures(void); static void _updateMatrices(void); static int _getMaxVerts(void); static int _getMaxIndices(void); inline static DWORD* _restartDrawPacket(DWORD* packet, int verts); inline static DWORD* _terminateDrawPacket(DWORD* packet); inline static DWORD* _restartIndexPacket(DWORD* packet, int numIndices); inline static DWORD* _terminateIndexPacket(DWORD* packet); static void _handleDrawOverflow(void); _XBOX inline static DWORD* _restartDrawPacket(DWORD* packet, int verts); static void _handleDrawOverflow(void); static void _drawElementsV(GLsizei count, const GLushort* indices); static void _drawElementsVN(GLsizei count, const GLushort* indices); static void _drawElementsVC(GLsizei count, const GLushort* indices); static void _drawElementsVCN(GLsizei count, const GLushort* indices); static void _drawElementsVCT(GLsizei count, const GLushort* indices); static void _drawElementsVCNT(GLsizei count, const GLushort* indices); static void _drawElementsVCTT(GLsizei count, const GLushort* indices); static void _drawElementsVCNTT(GLsizei count, const GLushort* indices); static void _drawElementsVT(GLsizei count, const GLushort* indices); static void _drawElementsVNT(GLsizei count, const GLushort* indices); static void _drawElementsVTT(GLsizei count, const GLushort* indices); static void _drawElementsVNTT(GLsizei count, const GLushort* indices); static void _drawElementsLightShader(GLsizei count, const GLushort* indices); static void _drawElementsBumpShader(GLsizei count, const GLushort* indices); static void _drawElementsEnvShader(GLsizei count, const GLushort* indices); static void _drawArraysV(GLsizei first, GLsizei last); static void _drawArraysVN(GLsizei first, GLsizei last); static void _drawArraysVC(GLsizei first, GLsizei last); static void _drawArraysVCN(GLsizei first, GLsizei last); static void _drawArraysVCT(GLsizei first, GLsizei last); static void _drawArraysVCNT(GLsizei first, GLsizei last); static void _drawArraysVCTT(GLsizei first, GLsizei last); static void _drawArraysVCNTT(GLsizei first, GLsizei last); static void _drawArraysVT(GLsizei first, GLsizei last); static void _drawArraysVNT(GLsizei first, GLsizei last); static void _drawArraysVTT(GLsizei first, GLsizei last); static void _drawArraysVNTT(GLsizei first, GLsizei last); static int _getDrawFunc(void); static void dllAccum(GLenum op, GLfloat value); static void dllAlphaFunc(GLenum func, GLclampf ref); GLboolean dllAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences); static void dllArrayElement(GLint i); static void dllBeginEXT(GLenum mode, GLint verts, GLint colors, GLint normals, GLint tex0, GLint tex1); static void dllBegin(GLenum mode); GLboolean dllBeginFrame(void); static void dllBeginShadow(void); static void dllBindTexture(GLenum target, GLuint texture); static void dllBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); static void dllBlendFunc(GLenum sfactor, GLenum dfactor); static void dllCallList(GLuint lnum); static void dllCallLists(GLsizei n, GLenum type, const GLvoid *lists); static void dllClear(GLbitfield mask); static void dllClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); static void dllClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); static void dllClearDepth(GLclampd depth); static void dllClearIndex(GLfloat c); static void dllClearStencil(GLint s); static void dllClipPlane(GLenum plane, const GLdouble *equation); static void setIntColor(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); static void setFloatColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); static void dllColor3b(GLbyte red, GLbyte green, GLbyte blue); static void dllColor3bv(const GLbyte *v); static void dllColor3d(GLdouble red, GLdouble green, GLdouble blue); static void dllColor3dv(const GLdouble *v); static void dllColor3f(GLfloat red, GLfloat green, GLfloat blue); static void dllColor3fv(const GLfloat *v); static void dllColor3i(GLint red, GLint green, GLint blue); static void dllColor3iv(const GLint *v); static void dllColor3s(GLshort red, GLshort green, GLshort blue); static void dllColor3sv(const GLshort *v); static void dllColor3ub(GLubyte red, GLubyte green, GLubyte blue); static void dllColor3ubv(const GLubyte *v); static void dllColor3ui(GLuint red, GLuint green, GLuint blue); static void dllColor3uiv(const GLuint *v); static void dllColor3us(GLushort red, GLushort green, GLushort blue); static void dllColor3usv(const GLushort *v); static void dllColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); static void dllColor4bv(const GLbyte *v); static void dllColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); static void dllColor4dv(const GLdouble *v); static void dllColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); static void dllColor4fv(const GLfloat *v); static void dllColor4i(GLint red, GLint green, GLint blue, GLint alpha); static void dllColor4iv(const GLint *v); static void dllColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha); static void dllColor4sv(const GLshort *v); static void dllColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); static void dllColor4ubv(const GLubyte *v); static void dllColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha); static void dllColor4uiv(const GLuint *v); static void dllColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha); static void dllColor4usv(const GLushort *v); static void dllColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); static void dllColorMaterial(GLenum face, GLenum mode); static void dllColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); static void dllCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); static void dllCopyTexImage1D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); static void dllCopyTexImage2D(GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); static void dllCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); static void dllCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); static void dllCullFace(GLenum mode); static void dllDeleteLists(GLuint lnum, GLsizei range); static void dllDeleteTextures(GLsizei n, const GLuint *textures); static void dllDepthFunc(GLenum func); static void dllDepthMask(GLboolean flag); static void dllDepthRange(GLclampd zNear, GLclampd zFar); static void setPresent(bool vsync); static void setCap(GLenum cap, bool flag); static void dllDisable(GLenum cap); static void setArrayState(GLenum cap, bool state); static void dllDisableClientState(GLenum array); static void _convertQuadsToTris(GLint first, GLsizei count); static void _cleanupQuadsToTris(void); static void dllDrawArrays(GLenum mode, GLint first, GLsizei count); static void dllDrawBuffer(GLenum mode); static void PushIndices(GLsizei count, const GLushort *indices); static void dllDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); static void dllDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); static void dllEdgeFlag(GLboolean flag); static void dllEdgeFlagPointer(GLsizei stride, const GLvoid *pointer); static void dllEdgeFlagv(const GLboolean *flag); static void dllEnable(GLenum cap); static void dllEnableClientState(GLenum array); static void dllEnd(void); static void dllEndFrame(void); static void dllEndShadow(void); static void dllEndList(void); static void dllEvalCoord1d(GLdouble u); static void dllEvalCoord1dv(const GLdouble *u); static void dllEvalCoord1f(GLfloat u); static void dllEvalCoord1fv(const GLfloat *u); static void dllEvalCoord2d(GLdouble u, GLdouble v); static void dllEvalCoord2dv(const GLdouble *u); static void dllEvalCoord2f(GLfloat u, GLfloat v); static void dllEvalCoord2fv(const GLfloat *u); static void dllEvalMesh1(GLenum mode, GLint i1, GLint i2); static void dllEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); static void dllEvalPoint1(GLint i); static void dllEvalPoint2(GLint i, GLint j); static void dllFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer); static void dllFinish(void); static void dllFlush(void); static void dllFlushShadow(void); static D3DFOGMODE _convertFogMode(GLint param); static void dllFogf(GLenum pname, GLfloat param); static void dllFogfv(GLenum pname, const GLfloat *params); static void dllFogi(GLenum pname, GLint param); static void dllFogiv(GLenum pname, const GLint *params); static void dllFrontFace(GLenum mode); static void dllFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); GLuint dllGenLists(GLsizei range); static void dllGenTextures(GLsizei n, GLuint *textures); static void _getState(GLenum pname, T *params); static void dllGetBooleanv(GLenum pname, GLboolean *params); static void dllGetClipPlane(GLenum plane, GLdouble *equation); static void dllGetDoublev(GLenum pname, GLdouble *params); GLenum dllGetError(void); static void dllGetFloatv(GLenum pname, GLfloat *params); static void dllGetIntegerv(GLenum pname, GLint *params); static void dllGetLightfv(GLenum light, GLenum pname, GLfloat *params); static void dllGetLightiv(GLenum light, GLenum pname, GLint *params); static void dllGetMapdv(GLenum target, GLenum query, GLdouble *v); static void dllGetMapfv(GLenum target, GLenum query, GLfloat *v); static void dllGetMapiv(GLenum target, GLenum query, GLint *v); static void dllGetMaterialfv(GLenum face, GLenum pname, GLfloat *params); static void dllGetMaterialiv(GLenum face, GLenum pname, GLint *params); static void dllGetPixelMapfv(GLenum map, GLfloat *values); static void dllGetPixelMapuiv(GLenum map, GLuint *values); static void dllGetPixelMapusv(GLenum map, GLushort *values); static void dllGetPointerv(GLenum pname, GLvoid* *params); static void dllGetPolygonStipple(GLubyte *mask); const GLubyte * dllGetString(GLenum name); static void dllGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params); static void dllGetTexEnviv(GLenum target, GLenum pname, GLint *params); static void dllGetTexGendv(GLenum coord, GLenum pname, GLdouble *params); static void dllGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params); static void dllGetTexGeniv(GLenum coord, GLenum pname, GLint *params); static void dllGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); static void dllGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params); static void dllGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params); static void dllGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); static void dllGetTexParameteriv(GLenum target, GLenum pname, GLint *params); static void dllHint(GLenum target, GLenum mode); static void buildStrips(GLuint* len, GLsizei* num_lens, GLushort* dest, GLsizei* num_indices, const GLushort* src); void renderObject_Light( int numIndexes, const glIndex_t *indexes ); void renderObject_Bump(); void renderObject_Env(); static void dllIndexedTriToStrip(GLsizei count, const GLushort *indices); static void dllIndexMask(GLuint mask); static void dllIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer); static void dllIndexd(GLdouble c); static void dllIndexdv(const GLdouble *c); static void dllIndexf(GLfloat c); static void dllIndexfv(const GLfloat *c); static void dllIndexi(GLint c); static void dllIndexiv(const GLint *c); static void dllIndexs(GLshort c); static void dllIndexsv(const GLshort *c); static void dllIndexub(GLubyte c); static void dllIndexubv(const GLubyte *c); static void dllInitNames(void); static void dllInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer); GLboolean dllIsEnabled(GLenum cap); GLboolean dllIsList(GLuint lnum); GLboolean dllIsTexture(GLuint texture); static void dllLightModelf(GLenum pname, GLfloat param); static void dllLightModelfv(GLenum pname, const GLfloat *params); static void dllLightModeli(GLenum pname, GLint param); static void dllLightModeliv(GLenum pname, const GLint *params); static void dllLightf(GLenum light, GLenum pname, GLfloat param); static void dllLightfv(GLenum light, GLenum pname, const GLfloat *params); static void dllLighti(GLenum light, GLenum pname, GLint param); static void dllLightiv(GLenum light, GLenum pname, const GLint *params); static void dllLineStipple(GLint factor, GLushort pattern); static void dllLineWidth(GLfloat width); static void dllListBase(GLuint base); static void dllLoadIdentity(void); static void dllLoadMatrixd(const GLdouble *m); static void dllLoadMatrixf(const GLfloat *m); static void dllLoadName(GLuint name); static void dllLogicOp(GLenum opcode); static void dllMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); static void dllMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); static void dllMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); static void dllMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); static void dllMapGrid1d(GLint un, GLdouble u1, GLdouble u2); static void dllMapGrid1f(GLint un, GLfloat u1, GLfloat u2); static void dllMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); static void dllMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); static void dllMaterialf(GLenum face, GLenum pname, GLfloat param); static void dllMaterialfv(GLenum face, GLenum pname, const GLfloat *params); static void dllMateriali(GLenum face, GLenum pname, GLint param); static void dllMaterialiv(GLenum face, GLenum pname, const GLint *params); static void dllMatrixMode(GLenum mode); static void dllMultMatrixd(const GLdouble *m); static void dllMultMatrixf(const GLfloat *m); static void dllNewList(GLuint lnum, GLenum mode); static void setNormal(float x, float y, float z); static void dllNormal3b(GLbyte nx, GLbyte ny, GLbyte nz); static void dllNormal3bv(const GLbyte *v); static void dllNormal3d(GLdouble nx, GLdouble ny, GLdouble nz); static void dllNormal3dv(const GLdouble *v); static void dllNormal3f(GLfloat nx, GLfloat ny, GLfloat nz); static void dllNormal3fv(const GLfloat *v); static void dllNormal3i(GLint nx, GLint ny, GLint nz); static void dllNormal3iv(const GLint *v); static void dllNormal3s(GLshort nx, GLshort ny, GLshort nz); static void dllNormal3sv(const GLshort *v); static void dllNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer); static void dllOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); static void dllPassThrough(GLfloat token); static void dllPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values); static void dllPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values); static void dllPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values); static void dllPixelStoref(GLenum pname, GLfloat param); static void dllPixelStorei(GLenum pname, GLint param); static void dllPixelTransferf(GLenum pname, GLfloat param); static void dllPixelTransferi(GLenum pname, GLint param); static void dllPixelZoom(GLfloat xfactor, GLfloat yfactor); static void dllPointSize(GLfloat size); static void dllPolygonMode(GLenum face, GLenum mode); static void dllPolygonOffset(GLfloat factor, GLfloat units); static void dllPolygonStipple(const GLubyte *mask); static void dllPopAttrib(void); static void dllPopClientAttrib(void); static void dllPopMatrix(void); static void dllPopName(void); static void dllPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities); static void dllPushAttrib(GLbitfield mask); static void dllPushClientAttrib(GLbitfield mask); static void dllPushMatrix(void); static void dllPushName(GLuint name); static void dllRasterPos2d(GLdouble x, GLdouble y); static void dllRasterPos2dv(const GLdouble *v); static void dllRasterPos2f(GLfloat x, GLfloat y); static void dllRasterPos2fv(const GLfloat *v); static void dllRasterPos2i(GLint x, GLint y); static void dllRasterPos2iv(const GLint *v); static void dllRasterPos2s(GLshort x, GLshort y); static void dllRasterPos2sv(const GLshort *v); static void dllRasterPos3d(GLdouble x, GLdouble y, GLdouble z); static void dllRasterPos3dv(const GLdouble *v); static void dllRasterPos3f(GLfloat x, GLfloat y, GLfloat z); static void dllRasterPos3fv(const GLfloat *v); static void dllRasterPos3i(GLint x, GLint y, GLint z); static void dllRasterPos3iv(const GLint *v); static void dllRasterPos3s(GLshort x, GLshort y, GLshort z); static void dllRasterPos3sv(const GLshort *v); static void dllRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); static void dllRasterPos4dv(const GLdouble *v); static void dllRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); static void dllRasterPos4fv(const GLfloat *v); static void dllRasterPos4i(GLint x, GLint y, GLint z, GLint w); static void dllRasterPos4iv(const GLint *v); static void dllRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w); static void dllRasterPos4sv(const GLshort *v); static void dllReadBuffer(GLenum mode); static void dllReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei twidth, GLsizei theight, GLvoid *pixels); static void dllCopyBackBufferToTex(); static void dllCopyBackBufferToTexEXT(float width, float height, float u1, float v1, float u2, float v2); static void dllRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); static void dllRectdv(const GLdouble *v1, const GLdouble *v2); static void dllRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); static void dllRectfv(const GLfloat *v1, const GLfloat *v2); static void dllRecti(GLint x1, GLint y1, GLint x2, GLint y2); static void dllRectiv(const GLint *v1, const GLint *v2); static void dllRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2); static void dllRectsv(const GLshort *v1, const GLshort *v2); GLint dllRenderMode(GLenum mode); static void dllRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z); static void dllRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); static void dllScaled(GLdouble x, GLdouble y, GLdouble z); static void dllScalef(GLfloat x, GLfloat y, GLfloat z); static void dllScissor(GLint x, GLint y, GLsizei width, GLsizei height); static void dllSelectBuffer(GLsizei size, GLuint *buffer); static void dllShadeModel(GLenum mode); static void dllStencilFunc(GLenum func, GLint ref, GLuint mask); static void dllStencilMask(GLuint mask); static D3DSTENCILOP _convertStencilOp(GLenum op); static void dllStencilOp(GLenum fail, GLenum zfail, GLenum zpass); static void dllTexCoord1d(GLdouble s); static void dllTexCoord1dv(const GLdouble *v); static void dllTexCoord1f(GLfloat s); static void dllTexCoord1fv(const GLfloat *v); static void dllTexCoord1i(GLint s); static void dllTexCoord1iv(const GLint *v); static void dllTexCoord1s(GLshort s); static void dllTexCoord1sv(const GLshort *v); static void setTexCoord(float s, float t); static void dllTexCoord2d(GLdouble s, GLdouble t); static void dllTexCoord2dv(const GLdouble *v); static void dllTexCoord2f(GLfloat s, GLfloat t); static void dllTexCoord2fv(const GLfloat *v); static void dllTexCoord2i(GLint s, GLint t); static void dllTexCoord2iv(const GLint *v); static void dllTexCoord2s(GLshort s, GLshort t); static void dllTexCoord2sv(const GLshort *v); static void dllTexCoord3d(GLdouble s, GLdouble t, GLdouble r); static void dllTexCoord3dv(const GLdouble *v); static void dllTexCoord3f(GLfloat s, GLfloat t, GLfloat r); static void dllTexCoord3fv(const GLfloat *v); static void dllTexCoord3i(GLint s, GLint t, GLint r); static void dllTexCoord3iv(const GLint *v); static void dllTexCoord3s(GLshort s, GLshort t, GLshort r); static void dllTexCoord3sv(const GLshort *v); static void dllTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q); static void dllTexCoord4dv(const GLdouble *v); static void dllTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q); static void dllTexCoord4fv(const GLfloat *v); static void dllTexCoord4i(GLint s, GLint t, GLint r, GLint q); static void dllTexCoord4iv(const GLint *v); static void dllTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q); static void dllTexCoord4sv(const GLshort *v); static void dllTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); static void dllTexEnvf(GLenum target, GLenum pname, GLfloat param); static void dllTexEnvfv(GLenum target, GLenum pname, const GLfloat *params); static void dllTexEnvi(GLenum target, GLenum pname, GLint param); static void dllTexEnviv(GLenum target, GLenum pname, const GLint *params); static void dllTexGend(GLenum coord, GLenum pname, GLdouble param); static void dllTexGendv(GLenum coord, GLenum pname, const GLdouble *params); static void dllTexGenf(GLenum coord, GLenum pname, GLfloat param); static void dllTexGenfv(GLenum coord, GLenum pname, const GLfloat *params); static void dllTexGeni(GLenum coord, GLenum pname, GLint param); static void dllTexGeniv(GLenum coord, GLenum pname, const GLint *params); static void dllTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); static void _texImageDDS(glwstate_t::TextureInfo* info, GLint numlevels, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels); static void _texImageRGBA(glwstate_t::TextureInfo* info, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLenum format, const GLvoid *pixels); static void dllTexImage2DEXT(GLenum target, GLint level, GLint numlevels, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); static void dllTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); static void dllTexParameteri(GLenum target, GLenum pname, GLint param); static void dllTexParameterf(GLenum target, GLenum pname, GLfloat param); static void dllTexParameterfv(GLenum target, GLenum pname, const GLfloat *params); static void dllTexParameteriv(GLenum target, GLenum pname, const GLint *params); static void dllTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); static void dllTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); static void dllTranslated(GLdouble x, GLdouble y, GLdouble z); static void dllTranslatef(GLfloat x, GLfloat y, GLfloat z); static void setVertex(float x, float y, float z); static void dllVertex2d(GLdouble x, GLdouble y); static void dllVertex2dv(const GLdouble *v); static void dllVertex2f(GLfloat x, GLfloat y); static void dllVertex2fv(const GLfloat *v); static void dllVertex2i(GLint x, GLint y); static void dllVertex2iv(const GLint *v); static void dllVertex2s(GLshort x, GLshort y); static void dllVertex2sv(const GLshort *v); static void dllVertex3d(GLdouble x, GLdouble y, GLdouble z); static void dllVertex3dv(const GLdouble *v); static void dllVertex3f(GLfloat x, GLfloat y, GLfloat z); static void dllVertex3fv(const GLfloat *v); static void dllVertex3i(GLint x, GLint y, GLint z); static void dllVertex3iv(const GLint *v); static void dllVertex3s(GLshort x, GLshort y, GLshort z); static void dllVertex3sv(const GLshort *v); static void dllVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w); static void dllVertex4dv(const GLdouble *v); static void dllVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w); static void dllVertex4fv(const GLfloat *v); static void dllVertex4i(GLint x, GLint y, GLint z, GLint w); static void dllVertex4iv(const GLint *v); static void dllVertex4s(GLshort x, GLshort y, GLshort z, GLshort w); static void dllVertex4sv(const GLshort *v); static void dllVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); static void dllViewport(GLint x, GLint y, GLsizei width, GLsizei height); static void dllMultiTexCoord2fARB(GLenum texture, GLfloat s, GLfloat t); static void dllActiveTextureARB(GLenum texture); static void dllClientActiveTextureARB(GLenum texture); void QGL_Shutdown( void ); qboolean QGL_Init( const char *dllname ); void QGL_EnableLogging( qboolean enable ); static void D3D_AutoPerfData_f( void ); static void _createWindow(int width, int height, int colorbits, qboolean cdsFullscreen); static LightEffects *getLightEffects( void ); void GLW_Init(int width, int height, int colorbits, qboolean cdsFullscreen); void GLW_Shutdown(void); bool CreateVertexShader( const CHAR* strFilename, const DWORD* pdwVertexDecl, DWORD* pdwVertexShader ); bool CreatePixelShader( const CHAR* strFilename, DWORD* pdwPixelShader );

f619b59c51c1eb9e9a8f4cd8d8bf09e086510607ac16bacd8fd79e14a8c50594

AzamYahya

shogun

src/shogun/multiclass/ShareBoostOptimizer.cpp

ShareBoostOptimizer::lbfgs_evaluate

float64_t ShareBoostOptimizer::lbfgs_evaluate(void *userdata, const float64_t *W, float64_t *grad, const int32_t n, const float64_t step) { ShareBoostOptimizer *optimizer = static_cast<ShareBoostOptimizer *>(userdata); optimizer->m_sb->compute_pred(W); optimizer->m_sb->compute_rho(); int32_t m = optimizer->m_sb->m_activeset.vlen; int32_t k = optimizer->m_sb->m_multiclass_strategy->get_num_classes(); SGMatrix<float64_t> fea = optimizer->m_sb->m_fea; CMulticlassLabels *lab = dynamic_cast<CMulticlassLabels *>(optimizer->m_sb->m_labels); for (int32_t i=0; i < m; ++i) { for (int32_t j=0; j < k; ++j) { int32_t idx = j*m + i; float64_t g=0; for (int32_t ii=0; ii < fea.num_cols; ++ii) g += fea(optimizer->m_sb->m_activeset[i], ii) * (optimizer->m_sb->m_rho(j,ii)/optimizer->m_sb->m_rho_norm[ii] - (j == lab->get_int_label(ii))); g /= fea.num_cols; grad[idx] = g; } } float64_t objval = 0; for (int32_t ii=0; ii < fea.num_cols; ++ii) { objval += CMath::log(optimizer->m_sb->m_rho_norm[ii]); } objval /= fea.num_cols; return objval; }

void ShareBoostOptimizer::optimize();

a0d90f1e6b67086890a70ae21cefdb3d88a2416781d3d086b0271bc6845484ba

mrdev023

MrDev023-Cpp-Engine

src/audio/audio.cpp

Audio::loadSound

ALuint Audio::loadSound(std::string Filename){ std::string* path = new std::string("res/sounds/"); Filename = *path + Filename; delete path; SF_INFO FileInfos; SNDFILE* File = sf_open(Filename.c_str(), SFM_READ, &FileInfos); if (File == NULL){ printf("%s\n",sf_strerror(File)); return 0; } ALsizei NbSamples = static_cast<ALsizei>(FileInfos.channels * FileInfos.frames); ALsizei SampleRate = static_cast<ALsizei>(FileInfos.samplerate); std::vector<ALshort> Samples(NbSamples); if (sf_read_short(File, &Samples[0], NbSamples) < NbSamples){ printf("Error during load file data !\n"); return 0; } sf_close(File); ALenum Format; switch (FileInfos.channels) { case 1 : Format = AL_FORMAT_MONO16; break; case 2 : Format = AL_FORMAT_STEREO16; break; case 4 : Format = alGetEnumValue("AL_FORMAT_QUAD16"); break; case 6 : Format = alGetEnumValue("AL_FORMAT_51CHN16"); break; case 7 : Format = alGetEnumValue("AL_FORMAT_61CHN16"); break; case 8 : Format = alGetEnumValue("AL_FORMAT_71CHN16"); break; default : return 0; } ALuint Buffer; alGenBuffers(1, &Buffer); int sec = NbSamples/FileInfos.channels/SampleRate; int min = sec/60; sec -= min * 60; alBufferData(Buffer, Format, &Samples[0], NbSamples * sizeof(ALushort), SampleRate); if (alGetError() != AL_NO_ERROR){ printf("OPENAL ERROR DURING LOAD FILE !\n"); return 0; } printf("Audio ressource %s loaded ! (channels: %d,SampleRate: %d,Time: %d:%d)\n",Filename.c_str(),FileInfos.channels,SampleRate,min,sec); return Buffer; } ALuint A

dio::createSource(ALuint* Buffer); ::createSource(const std::string f); playSource(ALuint* Source); destroySound(ALuint* Buffer); destroySource(ALuint* Source); ::getSourceState(ALuint* Source); getSourceSecOffSet(ALuint* Source); enAL(); (); g(ALuint* Source); ition(float x,float y,float z); ity(float x,float y,float z); n(float forwardx,float forwardy,float forwardz,float upx,float upy,float upz); Source,bool sur); uint* Source,float x,float y,float z); uint* Source,float x,float y,float z); int* Source,bool loop); * Source,float gain);

ae7b43209236f2f2fdc64d5bc7dfdc9bb21513e95f0d209dd31cde7893dd136a

Hotspotmar

ouzel

ouzel/math/Vector4.cpp

Vector4::smooth

void Vector4::smooth(const Vector4& target, float elapsedTime, float responseTime) { if (elapsedTime > 0) { *this += (target - *this) * (elapsedTime / (elapsedTime + responseTime)); } }

Vector4::Vector4(const Vector4& p1, const Vector4& p2); Vector4::Vector4(const Vector2& vec); Vector4& Vector4::operator=(const Vector2& vec); Vector4::Vector4(const Vector3& vec); Vector4& Vector4::operator=(const Vector3& vec); Vector4::Vector4(const Color& color); Vector4& Vector4::operator=(const Color& color); float Vector4::angle(const Vector4& v1, const Vector4& v2); void Vector4::clamp(const Vector4& min, const Vector4& max); void Vector4::clamp(const Vector4& vec, const Vector4& min, const Vector4& max, Vector4& dst); float Vector4::distance(const Vector4& vec); float Vector4::length(); void Vector4::normalize(); float Vector4::getMin(); float Vector4::getMax();

9d9c248b598bd2d4cf93ec9739b7f2675ff160105c5f90a9e476357310cd9766

InfinityCore

InfinityCore

src/server/game/Entities/Player/Player.cpp

Player::LoadFromDB

bool Player::LoadFromDB(uint32 guid, SQLQueryHolder *holder) { PreparedQueryResult result = holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_FROM); if (!result) { sLog->outError(LOG_FILTER_PLAYER, "Player (GUID: %u) not found in table `characters`, can't load. ", guid); return false; } Field* fields = result->Fetch(); uint32 dbAccountId = fields[1].GetUInt32(); if (dbAccountId != GetSession()->GetAccountId()) { sLog->outError(LOG_FILTER_PLAYER, "Player (GUID: %u) loading from wrong account (is: %u, should be: %u)", guid, GetSession()->GetAccountId(), dbAccountId); return false; } if (holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_BANNED)) { sLog->outError(LOG_FILTER_PLAYER, "Player (GUID: %u) is banned, can't load.", guid); return false; } Object::_Create(guid, 0, HIGHGUID_PLAYER); m_name = fields[2].GetString(); if (ObjectMgr::CheckPlayerName(m_name) != CHAR_NAME_SUCCESS || (AccountMgr::IsPlayerAccount(GetSession()->GetSecurity()) && sObjectMgr->IsReservedName(m_name))) { PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ADD_AT_LOGIN_FLAG); stmt->setUInt16(0, uint16(AT_LOGIN_RENAME)); stmt->setUInt32(1, guid); CharacterDatabase.Execute(stmt); return false; } SetUInt64Value(OBJECT_FIELD_GUID, MAKE_NEW_GUID(guid, 0, HIGHGUID_PLAYER)); uint8 Gender = fields[5].GetUInt8(); if (!IsValidGender(Gender)) { sLog->outError(LOG_FILTER_PLAYER, "Player (GUID: %u) has wrong gender (%hu), can't be loaded.", guid, Gender); return false; } uint32 bytes0 = 0; bytes0 |= fields[3].GetUInt8(); bytes0 |= fields[4].GetUInt8() << 8; bytes0 |= Gender << 16; SetUInt32Value(UNIT_FIELD_BYTES_0, bytes0); SetUInt32Value(UNIT_FIELD_LEVEL, fields[6].GetUInt8()); SetUInt32Value(PLAYER_XP, fields[7].GetUInt32()); _LoadIntoDataField(fields[55].GetCString(), PLAYER_EXPLORED_ZONES_1, PLAYER_EXPLORED_ZONES_SIZE); _LoadIntoDataField(fields[57].GetCString(), PLAYER__FIELD_KNOWN_TITLES, KNOWN_TITLES_SIZE*2); SetFloatValue(UNIT_FIELD_BOUNDINGRADIUS, DEFAULT_WORLD_OBJECT_SIZE); SetFloatValue(UNIT_FIELD_COMBATREACH, 1.5f); SetFloatValue(UNIT_FIELD_HOVERHEIGHT, 1.0f); SetUInt32Value(PLAYER_FIELD_HOME_PLAYER_REALM, realmID); m_achievementMgr->LoadFromDB(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_ACHIEVEMENTS), holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_CRITERIA_PROGRESS)); uint64 money = fields[8].GetUInt64(); if (money > MAX_MONEY_AMOUNT) money = MAX_MONEY_AMOUNT; SetMoney(money); SetUInt32Value(PLAYER_BYTES, fields[9].GetUInt32()); SetUInt32Value(PLAYER_BYTES_2, fields[10].GetUInt32()); SetByteValue(PLAYER_BYTES_3, 0, fields[5].GetUInt8()); SetByteValue(PLAYER_BYTES_3, 1, fields[45].GetUInt8()); SetUInt32Value(PLAYER_FLAGS, fields[11].GetUInt32()); SetInt32Value(PLAYER_FIELD_WATCHED_FACTION_INDEX, fields[44].GetUInt32()); SetByteValue(PLAYER_FIELD_BYTES, 2, fields[58].GetUInt8()); InitDisplayIds(); for (uint8 slot = EQUIPMENT_SLOT_START; slot < EQUIPMENT_SLOT_END; ++slot) { SetUInt64Value(PLAYER_FIELD_INV_SLOT_HEAD + (slot * 2), 0); SetVisibleItemSlot(slot, NULL); delete m_items[slot]; m_items[slot] = NULL; } sLog->outDebug(LOG_FILTER_PLAYER_LOADING, "Load Basic value of player %s is: ", m_name.c_str()); outDebugValues(); setFactionForRace(getRace()); if (!_LoadHomeBind(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_HOME_BIND))) return false; InitPrimaryProfessions(); uint32 transGUID = uint32(fields[31].GetUInt32()); Relocate(fields[12].GetFloat(), fields[13].GetFloat(), fields[14].GetFloat(), fields[16].GetFloat()); uint32 mapId = fields[15].GetUInt16(); uint32 instanceId = fields[52].GetUInt32(); uint32 dungeonDiff = fields[39].GetUInt8() & 0x0F; if (dungeonDiff >= MAX_DUNGEON_DIFFICULTY) dungeonDiff = DUNGEON_DIFFICULTY_NORMAL; uint32 raidDiff = (fields[39].GetUInt8() >> 4) & 0x0F; if (raidDiff >= MAX_RAID_DIFFICULTY) raidDiff = RAID_DIFFICULTY_10MAN_NORMAL; SetDungeonDifficulty(Difficulty(dungeonDiff)); SetRaidDifficulty(Difficulty(raidDiff)); std::string taxi_nodes = fields[38].GetString(); #define RelocateToHomebind(){ mapId = m_homebindMapId; instanceId = 0; Relocate(m_homebindX, m_homebindY, m_homebindZ); } _LoadGroup(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_GROUP)); _LoadArenaTeamInfo(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_ARENA_INFO)); for (uint32 arena_slot = 0; arena_slot < MAX_ARENA_SLOT; ++arena_slot) { uint32 arena_team_id = GetArenaTeamId(arena_slot); if (!arena_team_id) continue; if (ArenaTeam* at = sArenaTeamMgr->GetArenaTeamById(arena_team_id)) if (at->IsMember(GetGUID())) continue; for (int j = 0; j < 6; ++j) SetArenaTeamInfoField(arena_slot, ArenaTeamInfoType(j), 0); } _LoadCurrency(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_CURRENCY)); SetUInt32Value(PLAYER_FIELD_LIFETIME_HONORABLE_KILLS, fields[40].GetUInt32()); SetUInt16Value(PLAYER_FIELD_KILLS, 0, fields[41].GetUInt16()); SetUInt16Value(PLAYER_FIELD_KILLS, 1, fields[42].GetUInt16()); _LoadBoundInstances(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_BOUND_INSTANCES)); _LoadInstanceTimeRestrictions(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_INSTANCE_LOCK_TIMES)); _LoadBGData(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_BG_DATA)); GetSession()->SetPlayer(this); MapEntry const* mapEntry = sMapStore.LookupEntry(mapId); if (!mapEntry || !IsPositionValid()) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) have invalid coordinates (MapId: %u X: %f Y: %f Z: %f O: %f). Teleport to default race/class locations.", guid, mapId, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); RelocateToHomebind(); } else if (mapEntry && mapEntry->IsBattlegroundOrArena()) { Battleground* currentBg = NULL; if (m_bgData.bgInstanceID) currentBg = sBattlegroundMgr->GetBattleground(m_bgData.bgInstanceID, BATTLEGROUND_TYPE_NONE); bool player_at_bg = currentBg && currentBg->IsPlayerInBattleground(GetGUID()); if (player_at_bg && currentBg->GetStatus() != STATUS_WAIT_LEAVE) { BattlegroundQueueTypeId bgQueueTypeId = sBattlegroundMgr->BGQueueTypeId(currentBg->GetTypeID(), currentBg->GetArenaType()); AddBattlegroundQueueId(bgQueueTypeId); m_bgData.bgTypeID = currentBg->GetTypeID(); currentBg->EventPlayerLoggedIn(this); currentBg->AddOrSetPlayerToCorrectBgGroup(this, m_bgData.bgTeam); SetInviteForBattlegroundQueueType(bgQueueTypeId, currentBg->GetInstanceID()); } else { if (player_at_bg) currentBg->RemovePlayerAtLeave(GetGUID(), false, true); const WorldLocation& _loc = GetBattlegroundEntryPoint(); mapId = _loc.GetMapId(); instanceId = 0; if (int16(mapId) == int16(-1)) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) was in BG in database, but BG was not found, and entry point was invalid! Teleport to default race/class locations.", guid); RelocateToHomebind(); } else Relocate(&_loc); m_bgData.bgInstanceID = 0; } } else if (transGUID) { m_movementInfo.t_guid = MAKE_NEW_GUID(transGUID, 0, HIGHGUID_MO_TRANSPORT); m_movementInfo.t_pos.Relocate(fields[27].GetFloat(), fields[28].GetFloat(), fields[29].GetFloat(), fields[30].GetFloat()); if (!Trinity::IsValidMapCoord( GetPositionX()+m_movementInfo.t_pos.m_positionX, GetPositionY()+m_movementInfo.t_pos.m_positionY, GetPositionZ()+m_movementInfo.t_pos.m_positionZ, GetOrientation()+m_movementInfo.t_pos.GetOrientation()) || m_movementInfo.t_pos.m_positionX > 250 || m_movementInfo.t_pos.m_positionY > 250 || m_movementInfo.t_pos.m_positionZ > 250) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) have invalid transport coordinates (X: %f Y: %f Z: %f O: %f). Teleport to bind location.", guid, GetPositionX()+m_movementInfo.t_pos.m_positionX, GetPositionY()+m_movementInfo.t_pos.m_positionY, GetPositionZ()+m_movementInfo.t_pos.m_positionZ, GetOrientation()+m_movementInfo.t_pos.GetOrientation()); RelocateToHomebind(); } else { for (MapManager::TransportSet::iterator iter = sMapMgr->m_Transports.begin(); iter != sMapMgr->m_Transports.end(); ++iter) { if ((*iter)->GetGUIDLow() == transGUID) { m_transport = *iter; m_transport->AddPassenger(this); mapId = (m_transport->GetMapId()); break; } } if (!m_transport) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) have problems with transport guid (%u). Teleport to bind location.", guid, transGUID); RelocateToHomebind(); } } } else if (!taxi_nodes.empty()) { instanceId = 0; if (m_bgData.HasTaxiPath()) { for (int i = 0; i < 2; ++i) m_taxi.AddTaxiDestination(m_bgData.taxiPath[i]); } else if (!m_taxi.LoadTaxiDestinationsFromString(taxi_nodes, GetTeam())) { TaxiNodesEntry const* nodeEntry = NULL; if (uint32 node_id = m_taxi.GetTaxiSource()) nodeEntry = sTaxiNodesStore.LookupEntry(node_id); if (!nodeEntry) { sLog->outError(LOG_FILTER_PLAYER, "Character %u have wrong data in taxi destination list, teleport to homebind.", GetGUIDLow()); RelocateToHomebind(); } else { sLog->outError(LOG_FILTER_PLAYER, "Character %u have too short taxi destination list, teleport to original node.", GetGUIDLow()); mapId = nodeEntry->map_id; Relocate(nodeEntry->x, nodeEntry->y, nodeEntry->z, 0.0f); } m_taxi.ClearTaxiDestinations(); } if (uint32 node_id = m_taxi.GetTaxiSource()) { TaxiNodesEntry const* nodeEntry = sTaxiNodesStore.LookupEntry(node_id); if (nodeEntry && nodeEntry->map_id == GetMapId()) { ASSERT(nodeEntry); mapId = nodeEntry->map_id; Relocate(nodeEntry->x, nodeEntry->y, nodeEntry->z, 0.0f); } } } mapEntry = sMapStore.LookupEntry(mapId); if (mapEntry) { if (GetSession()->Expansion() < mapEntry->Expansion()) { sLog->outDebug(LOG_FILTER_PLAYER_LOADING, "Player %s using client without required expansion tried login at non accessible map %u", GetName().c_str(), mapId); RelocateToHomebind(); } if (instanceId) if (InstanceSave* save = GetInstanceSave(mapId, mapEntry->IsRaid())) if (save->GetInstanceId() != instanceId) instanceId = 0; } Map* map = sMapMgr->CreateMap(mapId, this); if (!map) { instanceId = 0; AreaTrigger const* at = sObjectMgr->GetGoBackTrigger(mapId); if (at) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) is teleported to gobacktrigger (Map: %u X: %f Y: %f Z: %f O: %f).", guid, mapId, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); Relocate(at->target_X, at->target_Y, at->target_Z, GetOrientation()); mapId = at->target_mapId; } else { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) is teleported to home (Map: %u X: %f Y: %f Z: %f O: %f).", guid, mapId, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); RelocateToHomebind(); } map = sMapMgr->CreateMap(mapId, this); if (!map) { PlayerInfo const* info = sObjectMgr->GetPlayerInfo(getRace(), getClass()); mapId = info->mapId; Relocate(info->positionX, info->positionY, info->positionZ, 0.0f); sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) have invalid coordinates (X: %f Y: %f Z: %f O: %f). Teleport to default race/class locations.", guid, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); map = sMapMgr->CreateMap(mapId, this); if (!map) { sLog->outError(LOG_FILTER_PLAYER, "Player (guidlow %d) has invalid default map coordinates (X: %f Y: %f Z: %f O: %f). or instance couldn't be created", guid, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation()); return false; } } } if (instanceId && !sInstanceSaveMgr->GetInstanceSave(instanceId) && !map->IsBattlegroundOrArena()) { AreaTrigger const* at = sObjectMgr->GetMapEntranceTrigger(mapId); if (at) Relocate(at->target_X, at->target_Y, at->target_Z, at->target_Orientation); else { sLog->outError(LOG_FILTER_PLAYER, "Player %s(GUID: %u) logged in to a reset instance (map: %u) and there is no area-trigger leading to this map. Thus he can't be ported back to the entrance. This _might_ be an exploit attempt.", GetName().c_str(), GetGUIDLow(), mapId); RelocateToHomebind(); } } SetMap(map); StoreRaidMapDifficulty(); m_nextSave = urand(m_nextSave/2, m_nextSave*3/2); SaveRecallPosition(); time_t now = time(NULL); time_t logoutTime = time_t(fields[22].GetUInt32()); uint32 time_diff = uint32(now - logoutTime); uint8 newDrunkValue = 0; if (time_diff < uint32(GetDrunkValue()) * 9) newDrunkValue = GetDrunkValue() - time_diff / 9; SetDrunkValue(newDrunkValue); m_cinematic = fields[18].GetUInt8(); m_Played_time[PLAYED_TIME_TOTAL]= fields[19].GetUInt32(); m_Played_time[PLAYED_TIME_LEVEL]= fields[20].GetUInt32(); SetTalentResetCost(fields[24].GetUInt32()); SetTalentResetTime(time_t(fields[25].GetUInt32())); m_taxi.LoadTaxiMask(fields[17].GetString()); uint32 extraflags = fields[32].GetUInt16(); m_stableSlots = fields[33].GetUInt8(); if (m_stableSlots > MAX_PET_STABLES) { sLog->outError(LOG_FILTER_PLAYER, "Player can have not more %u stable slots, but have in DB %u", MAX_PET_STABLES, uint32(m_stableSlots)); m_stableSlots = MAX_PET_STABLES; } m_atLoginFlags = fields[34].GetUInt16(); m_lastHonorUpdateTime = logoutTime; UpdateHonorFields(); m_deathExpireTime = time_t(fields[37].GetUInt32()); if (m_deathExpireTime > now+MAX_DEATH_COUNT*DEATH_EXPIRE_STEP) m_deathExpireTime = now+MAX_DEATH_COUNT*DEATH_EXPIRE_STEP-1; SetUInt64Value(UNIT_FIELD_CHANNEL_OBJECT, 0); SetUInt32Value(UNIT_CHANNEL_SPELL, 0); SetOwnerGUID(0); SetUInt64Value(UNIT_FIELD_CHARMEDBY, 0); SetUInt64Value(UNIT_FIELD_CHARM, 0); SetUInt64Value(UNIT_FIELD_SUMMON, 0); SetUInt64Value(PLAYER_FARSIGHT, 0); SetCreatorGUID(0); RemoveFlag(UNIT_FIELD_FLAGS_2, UNIT_FLAG2_FORCE_MOVEMENT); SetUInt32Value(PLAYER_TRACK_CREATURES, 0); SetUInt32Value(PLAYER_TRACK_RESOURCES, 0); ClearInCombat(); SetUInt64Value(PLAYER_DUEL_ARBITER, 0); SetUInt32Value(PLAYER_DUEL_TEAM, 0); InitStatsForLevel(); InitGlyphsForLevel(); InitTaxiNodesForLevel(); InitRunes(); m_rest_bonus = fields[21].GetFloat(); if (time_diff > 0) { float bubble0 = 0.031f; float bubble1 = 0.125f; float bubble = fields[23].GetUInt8() > 0 ? bubble1*sWorld->getRate(RATE_REST_OFFLINE_IN_TAVERN_OR_CITY) : bubble0*sWorld->getRate(RATE_REST_OFFLINE_IN_WILDERNESS); SetRestBonus(GetRestBonus()+ time_diff*((float)GetUInt32Value(PLAYER_NEXT_LEVEL_XP)/72000)*bubble); } _LoadSkills(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_SKILLS)); UpdateSkillsForLevel(); SetSpecsCount(fields[53].GetUInt8()); SetActiveSpec(fields[54].GetUInt8()); if (GetSpecsCount() > MAX_TALENT_SPECS || GetActiveSpec() > MAX_TALENT_SPEC || GetSpecsCount() < MIN_TALENT_SPECS) { SetActiveSpec(0); sLog->outError(LOG_FILTER_PLAYER, "Player %s(GUID: %u) has SpecCount = %u and ActiveSpec = %u.", GetName().c_str(), GetGUIDLow(), GetSpecsCount(), GetActiveSpec()); } _LoadTalents(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_TALENTS)); _LoadSpells(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_SPELLS)); _LoadGlyphs(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_GLYPHS)); _LoadAuras(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_AURAS), time_diff); _LoadGlyphAuras(); if (HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_GHOST)) m_deathState = DEAD; _LoadQuestStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_QUEST_STATUS)); _LoadQuestStatusRewarded(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_QUEST_STATUS_REW)); _LoadDailyQuestStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_DAILY_QUEST_STATUS)); _LoadWeeklyQuestStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_WEEKLY_QUEST_STATUS)); _LoadSeasonalQuestStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_SEASONAL_QUEST_STATUS)); _LoadMonthlyQuestStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_MONTHLY_QUEST_STATUS)); _LoadRandomBGStatus(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_RANDOM_BG)); InitTalentForLevel(); learnDefaultSpells(); m_reputationMgr->LoadFromDB(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_REPUTATION)); _LoadInventory(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_INVENTORY), time_diff); if (IsVoidStorageUnlocked()) _LoadVoidStorage(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_VOID_STORAGE)); UpdateItemDuration(time_diff, true); _LoadActions(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_ACTIONS)); _LoadMailInit(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_MAIL_COUNT), holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_MAIL_DATE)); m_social = sSocialMgr->LoadFromDB(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_SOCIAL_LIST), GetGUIDLow()); uint32 curTitle = fields[43].GetUInt32(); if (curTitle && !HasTitle(curTitle)) curTitle = 0; SetUInt32Value(PLAYER_CHOSEN_TITLE, curTitle); SetFallInformation(0, GetPositionZ()); _LoadSpellCooldowns(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_SPELL_COOLDOWNS)); if (!isAlive()) RemoveAllAurasOnDeath(); else RemoveAllAurasRequiringDeadTarget(); SetCanModifyStats(true); UpdateAllStats(); uint32 savedHealth = fields[46].GetUInt32(); SetHealth(savedHealth > GetMaxHealth() ? GetMaxHealth() : savedHealth); uint32 loadedPowers = 0; for (uint32 i = 0; i < MAX_POWERS; ++i) { if (GetPowerIndexByClass(Powers(i), getClass()) != MAX_POWERS) { uint32 savedPower = fields[47+loadedPowers].GetUInt32(); uint32 maxPower = GetUInt32Value(UNIT_FIELD_MAXPOWER1 + loadedPowers); SetPower(Powers(i), (savedPower > maxPower) ? maxPower : savedPower); if (++loadedPowers >= MAX_POWERS_PER_CLASS) break; } } for (; loadedPowers < MAX_POWERS_PER_CLASS; ++loadedPowers) SetUInt32Value(UNIT_FIELD_POWER1 + loadedPowers, 0); SetPower(POWER_ECLIPSE, 0); Tokenizer talentTrees(fields[26].GetString(), ' ', MAX_TALENT_SPECS); for (uint8 i = 0; i < MAX_TALENT_SPECS; ++i) { if (i >= talentTrees.size()) break; uint32 talentTree = atol(talentTrees[i]); if (sTalentTabStore.LookupEntry(talentTree)) SetPrimaryTalentTree(i, talentTree); else if (i == GetActiveSpec() && talentTree != 0) SetAtLoginFlag(AT_LOGIN_RESET_TALENTS); } sLog->outDebug(LOG_FILTER_PLAYER_LOADING, "The value of player %s after load item and aura is: ", m_name.c_str()); outDebugValues(); if (!AccountMgr::IsPlayerAccount(GetSession()->GetSecurity())) { switch (sWorld->getIntConfig(CONFIG_GM_LOGIN_STATE)) { default: case 0: break; case 1: SetGameMaster(true); break; case 2: if (extraflags & PLAYER_EXTRA_GM_ON) SetGameMaster(true); break; } switch (sWorld->getIntConfig(CONFIG_GM_VISIBLE_STATE)) { default: case 0: SetGMVisible(false); break; case 1: break; case 2: if (extraflags & PLAYER_EXTRA_GM_INVISIBLE) SetGMVisible(false); break; } switch (sWorld->getIntConfig(CONFIG_GM_CHAT)) { default: case 0: break; case 1: SetGMChat(true); break; case 2: if (extraflags & PLAYER_EXTRA_GM_CHAT) SetGMChat(true); break; } switch (sWorld->getIntConfig(CONFIG_GM_WHISPERING_TO)) { default: case 0: break; case 1: SetAcceptWhispers(true); break; case 2: if (extraflags & PLAYER_EXTRA_ACCEPT_WHISPERS) SetAcceptWhispers(true); break; } } m_grantableLevels = fields[59].GetUInt8(); if (GetSession()->IsARecruiter() || (GetSession()->GetRecruiterId() != 0)) SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_REFER_A_FRIEND); if (m_grantableLevels > 0) SetByteValue(PLAYER_FIELD_BYTES, 1, 0x01); _LoadDeclinedNames(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_DECLINED_NAMES)); m_achievementMgr->CheckAllAchievementCriteria(this); _LoadEquipmentSets(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_EQUIPMENT_SETS)); _LoadCUFProfiles(holder->GetPreparedResult(PLAYER_LOGIN_QUERY_LOAD_CUF_PROFILES)); return true; }

PlayerTaxi::PlayerTaxi(); void PlayerTaxi::InitTaxiNodesForLevel(uint32 race, uint32 chrClass, uint8 level); void PlayerTaxi::LoadTaxiMask(std::string const &data); void PlayerTaxi::AppendTaximaskTo(ByteBuffer& data, bool all); bool PlayerTaxi::LoadTaxiDestinationsFromString(const std::string& values, uint32 team); std::string PlayerTaxi::SaveTaxiDestinationsToString(); uint32 PlayerTaxi::GetCurrentTaxiPath(); std::ostringstream& operator<< (std::ostringstream& ss, PlayerTaxi const& taxi); TradeData* TradeData::GetTraderData(); Item* TradeData::GetItem(TradeSlots slot); bool TradeData::HasItem(uint64 itemGuid); TradeSlots TradeData::GetTradeSlotForItem(uint64 itemGuid); Item* TradeData::GetSpellCastItem(); void TradeData::SetItem(TradeSlots slot, Item* item); void TradeData::SetSpell(uint32 spell_id, Item* castItem /*= NULL*/); void TradeData::SetMoney(uint64 money); void TradeData::Update(bool forTarget /*= true*/); void TradeData::SetAccepted(bool state, bool crosssend /*= false*/); KillRewarder::KillRewarder(Player* killer, Unit* victim, bool isBattleGround); inline void KillRewarder::_InitGroupData(); inline void KillRewarder::_InitXP(Player* player); inline void KillRewarder::_RewardHonor(Player* player); inline void KillRewarder::_RewardXP(Player* player, float rate); inline void KillRewarder::_RewardReputation(Player* player, float rate); inline void KillRewarder::_RewardKillCredit(Player* player); void KillRewarder::_RewardPlayer(Player* player, bool isDungeon); void KillRewarder::_RewardGroup(); void KillRewarder::Reward(); Player::Player(WorldSession* session); Player::~Player(); void Player::CleanupsBeforeDelete(bool finalCleanup); bool Player::Create(uint32 guidlow, CharacterCreateInfo* createInfo); bool Player::StoreNewItemInBestSlots(uint32 titem_id, uint32 titem_amount); void Player::SendMirrorTimer(MirrorTimerType Type, uint32 MaxValue, uint32 CurrentValue, int32 Regen); void Player::StopMirrorTimer(MirrorTimerType Type); bool Player::IsImmuneToEnvironmentalDamage(); uint32 Player::EnvironmentalDamage(EnviromentalDamage type, uint32 damage); int32 Player::getMaxTimer(MirrorTimerType timer); void Player::UpdateMirrorTimers(); void Player::HandleDrowning(uint32 time_diff); void Player::HandleSobering(); DrunkenState Player::GetDrunkenstateByValue(uint8 value); void Player::SetDrunkValue(uint8 newDrunkValue, uint32 itemId /*= 0*/); void Player::Update(uint32 p_time); void Player::setDeathState(DeathState s); bool Player::BuildEnumData(PreparedQueryResult result, ByteBuffer* dataBuffer, ByteBuffer* bitBuffer); bool Player::ToggleAFK(); bool Player::ToggleDND(); uint8 Player::GetChatTag(); void Player::SendTeleportPacket(Position &oldPos); bool Player::TeleportTo(uint32 mapid, float x, float y, float z, float orientation, uint32 options); bool Player::TeleportToBGEntryPoint(); void Player::ProcessDelayedOperations(); void Player::AddToWorld(); void Player::RemoveFromWorld(); void Player::RegenerateAll(); void Player::Regenerate(Powers power); void Player::RegenerateHealth(); void Player::ResetAllPowers(); bool Player::CanInteractWithQuestGiver(Object* questGiver); Creature* Player::GetNPCIfCanInteractWith(uint64 guid, uint32 npcflagmask); GameObject* Player::GetGameObjectIfCanInteractWith(uint64 guid, GameobjectTypes type); bool Player::IsUnderWater(); void Player::SetInWater(bool apply); void Player::SetGameMaster(bool on); void Player::SetGMVisible(bool on); bool Player::IsGroupVisibleFor(Player const* p); bool Player::IsInSameGroupWith(Player const* p); void Player::UninviteFromGroup(); void Player::RemoveFromGroup(Group* group, uint64 guid, RemoveMethod method /* = GROUP_REMOVEMETHOD_DEFAULT*/, uint64 kicker /* = 0 */, const char* reason /* = NULL */); void Player::SendLogXPGain(uint32 GivenXP, Unit* victim, uint32 BonusXP, bool recruitAFriend, float /*group_rate*/); void Player::GiveXP(uint32 xp, Unit* victim, float group_rate); void Player::GiveLevel(uint8 level); void Player::InitTalentForLevel(); void Player::InitStatsForLevel(bool reapplyMods); void Player::SendInitialSpells(); void Player::RemoveMail(uint32 id); void Player::SendMailResult(uint32 mailId, MailResponseType mailAction, MailResponseResult mailError, uint32 equipError, uint32 item_guid, uint32 item_count); void Player::SendNewMail(); void Player::UpdateNextMailTimeAndUnreads(); void Player::AddNewMailDeliverTime(time_t deliver_time); bool Player::AddTalent(uint32 spellId, uint8 spec, bool learning); bool Player::addSpell(uint32 spellId, bool active, bool learning, bool dependent, bool disabled, bool loading /*= false*/); void Player::AddTemporarySpell(uint32 spellId); void Player::RemoveTemporarySpell(uint32 spellId); bool Player::IsNeedCastPassiveSpellAtLearn(SpellInfo const* spellInfo); void Player::learnSpell(uint32 spell_id, bool dependent); void Player::removeSpell(uint32 spell_id, bool disabled, bool learn_low_rank); void Player::RemoveSpellCooldown(uint32 spell_id, bool update /* = false */); void Player::RemoveCategoryCooldown(uint32 cat); void Player::RemoveSpellCategoryCooldown(uint32 cat, bool update /* = false */); void Player::RemoveArenaSpellCooldowns(bool removeActivePetCooldowns); void Player::RemoveAllSpellCooldown(); void Player::_LoadSpellCooldowns(PreparedQueryResult result); void Player::_SaveSpellCooldowns(SQLTransaction& trans); uint32 Player::GetNextResetTalentsCost(); bool Player::ResetTalents(bool no_cost); Mail* Player::GetMail(uint32 id); void Player::BuildCreateUpdateBlockForPlayer(UpdateData* data, Player* target); void Player::DestroyForPlayer(Player* target, bool onDeath); bool Player::HasSpell(uint32 spell); bool Player::HasTalent(uint32 spell, uint8 spec); bool Player::HasActiveSpell(uint32 spell); TrainerSpellState Player::GetTrainerSpellState(TrainerSpell const* trainer_spell); void Player::DeleteFromDB(uint64 playerguid, uint32 accountId, bool updateRealmChars, bool deleteFinally); void Player::DeleteOldCharacters(); void Player::DeleteOldCharacters(uint32 keepDays); void Player::BuildPlayerRepop(); void Player::ResurrectPlayer(float restore_percent, bool applySickness); void Player::KillPlayer(); void Player::CreateCorpse(); void Player::SpawnCorpseBones(); Corpse* Player::GetCorpse(); void Player::DurabilityLossAll(double percent, bool inventory); void Player::DurabilityLoss(Item* item, double percent); void Player::DurabilityPointsLossAll(int32 points, bool inventory); void Player::DurabilityPointsLoss(Item* item, int32 points); void Player::DurabilityPointLossForEquipSlot(EquipmentSlots slot); uint32 Player::DurabilityRepairAll(bool cost, float discountMod, bool guildBank); uint32 Player::DurabilityRepair(uint16 pos, bool cost, float discountMod, bool guildBank); void Player::RepopAtGraveyard(); bool Player::CanJoinConstantChannelInZone(ChatChannelsEntry const* channel, AreaTableEntry const* zone); void Player::JoinedChannel(Channel* c); void Player::LeftChannel(Channel* c); void Player::CleanupChannels(); void Player::UpdateLocalChannels(uint32 newZone); void Player::LeaveLFGChannel(); void Player::HandleBaseModValue(BaseModGroup modGroup, BaseModType modType, float amount, bool apply); float Player::GetBaseModValue(BaseModGroup modGroup, BaseModType modType); float Player::GetTotalBaseModValue(BaseModGroup modGroup); float Player::GetMeleeCritFromAgility(); void Player::GetDodgeFromAgility(float &diminishing, float &nondiminishing); float Player::GetSpellCritFromIntellect(); float Player::GetRatingMultiplier(CombatRating cr); float Player::GetRatingBonusValue(CombatRating cr); float Player::GetExpertiseDodgeOrParryReduction(WeaponAttackType attType); float Player::OCTRegenMPPerSpirit(); void Player::ApplyRatingMod(CombatRating cr, int32 value, bool apply); void Player::UpdateRating(CombatRating cr); void Player::UpdateAllRatings(); void Player::SetRegularAttackTime(); bool Player::UpdateSkill(uint32 skill_id, uint32 step); inline int SkillGainChance(uint32 SkillValue, uint32 GrayLevel, uint32 GreenLevel, uint32 YellowLevel); bool Player::UpdateCraftSkill(uint32 spellid); bool Player::UpdateGatherSkill(uint32 SkillId, uint32 SkillValue, uint32 RedLevel, uint32 Multiplicator); bool Player::UpdateFishingSkill(); bool Player::UpdateSkillPro(uint16 skillId, int32 chance, uint32 step); void Player::ModifySkillBonus(uint32 skillid, int32 val, bool talent); void Player::UpdateSkillsForLevel(); void Player::UpdateSkillsToMaxSkillsForLevel(); void Player::SetSkill(uint16 id, uint16 step, uint16 newVal, uint16 maxVal); bool Player::HasSkill(uint32 skill); uint16 Player::GetSkillStep(uint16 skill); uint16 Player::GetSkillValue(uint32 skill); uint16 Player::GetMaxSkillValue(uint32 skill); uint16 Player::GetPureMaxSkillValue(uint32 skill); uint16 Player::GetBaseSkillValue(uint32 skill); uint16 Player::GetPureSkillValue(uint32 skill); int16 Player::GetSkillPermBonusValue(uint32 skill); int16 Player::GetSkillTempBonusValue(uint32 skill); void Player::SendActionButtons(uint32 state); bool Player::IsActionButtonDataValid(uint8 button, uint32 action, uint8 type); ActionButton* Player::addActionButton(uint8 button, uint32 action, uint8 type); void Player::removeActionButton(uint8 button); ActionButton const* Player::GetActionButton(uint8 button); bool Player::UpdatePosition(float x, float y, float z, float orientation, bool teleport); void Player::SaveRecallPosition(); void Player::SendMessageToSetInRange(WorldPacket* data, float dist, bool self); void Player::SendMessageToSetInRange(WorldPacket* data, float dist, bool self, bool own_team_only); void Player::SendMessageToSet(WorldPacket* data, Player const* skipped_rcvr); void Player::SendDirectMessage(WorldPacket* data); void Player::SendCinematicStart(uint32 CinematicSequenceId); void Player::SendMovieStart(uint32 MovieId); void Player::CheckAreaExploreAndOutdoor(); uint32 Player::TeamForRace(uint8 race); void Player::setFactionForRace(uint8 race); ReputationRank Player::GetReputationRank(uint32 faction); int32 Player::CalculateReputationGain(ReputationSource source, uint32 creatureOrQuestLevel, int32 rep, int32 faction, bool noQuestBonus); void Player::RewardReputation(Unit* victim, float rate); void Player::RewardReputation(Quest const* quest); void Player::UpdateHonorFields(); bool Player::RewardHonor(Unit* victim, uint32 groupsize, int32 honor, bool pvptoken); void Player::_LoadCurrency(PreparedQueryResult result); void Player::_SaveCurrency(SQLTransaction& trans); void Player::SendNewCurrency(uint32 id); void Player::SendCurrencies(); void Player::SendPvpRewards(); uint32 Player::GetCurrency(uint32 id, bool precision); uint32 Player::GetCurrencyOnWeek(uint32 id, bool precision); bool Player::HasCurrency(uint32 id, uint32 count); void Player::ModifyCurrency(uint32 id, int32 count, bool printLog/* = true*/, bool ignoreMultipliers/* = false*/); void Player::SetCurrency(uint32 id, uint32 count, bool printLog /*= true*/); uint32 Player::GetCurrencyWeekCap(uint32 id, bool usePrecision); void Player::ResetCurrencyWeekCap(); uint32 Player::_GetCurrencyWeekCap(const CurrencyTypesEntry* currency); void Player::SetInGuild(uint32 guildId); uint32 Player::GetGuildIdFromDB(uint64 guid); uint8 Player::GetRankFromDB(uint64 guid); void Player::SetArenaTeamInfoField(uint8 slot, ArenaTeamInfoType type, uint32 value); uint32 Player::GetArenaTeamIdFromDB(uint64 guid, uint8 type); uint32 Player::GetZoneIdFromDB(uint64 guid); uint32 Player::GetLevelFromDB(uint64 guid); void Player::UpdateArea(uint32 newArea); void Player::UpdateZone(uint32 newZone, uint32 newArea); void Player::CheckDuelDistance(time_t currTime); bool Player::IsOutdoorPvPActive(); void Player::DuelComplete(DuelCompleteType type); void Player::_ApplyItemMods(Item* item, uint8 slot, bool apply); void Player::_ApplyItemBonuses(ItemTemplate const* proto, uint8 slot, bool apply, bool only_level_scale /*= false*/); void Player::_ApplyWeaponDamage(uint8 slot, ItemTemplate const* proto, ScalingStatValuesEntry const* ssv, bool apply); void Player::_ApplyWeaponDependentAuraMods(Item* item, WeaponAttackType attackType, bool apply); void Player::_ApplyWeaponDependentAuraCritMod(Item* item, WeaponAttackType attackType, AuraEffect const* aura, bool apply); void Player::_ApplyWeaponDependentAuraDamageMod(Item* item, WeaponAttackType attackType, AuraEffect const* aura, bool apply); void Player::ApplyItemEquipSpell(Item* item, bool apply, bool form_change); void Player::ApplyEquipSpell(SpellInfo const* spellInfo, Item* item, bool apply, bool form_change); void Player::UpdateEquipSpellsAtFormChange(); void Player::CastItemCombatSpell(Unit* target, WeaponAttackType attType, uint32 procVictim, uint32 procEx); void Player::CastItemCombatSpell(Unit* target, WeaponAttackType attType, uint32 procVictim, uint32 procEx, Item* item, ItemTemplate const* proto); void Player::CastItemUseSpell(Item* item, SpellCastTargets const& targets, uint8 cast_count, uint32 glyphIndex); void Player::_RemoveAllItemMods(); void Player::_ApplyAllItemMods(); void Player::_ApplyAllLevelScaleItemMods(bool apply); void Player::RemovedInsignia(Player* looterPlr); void Player::SendLootRelease(uint64 guid); void Player::SendLoot(uint64 guid, LootType loot_type); void Player::SendNotifyLootMoneyRemoved(); void Player::SendNotifyLootItemRemoved(uint8 lootSlot); void Player::SendUpdateWorldState(uint32 Field, uint32 Value); void Player::SendInitWorldStates(uint32 zoneid, uint32 areaid); void Player::SendBGWeekendWorldStates(); void Player::SendBattlefieldWorldStates(); uint32 Player::GetXPRestBonus(uint32 xp); void Player::SetBindPoint(uint64 guid); void Player::SendTalentWipeConfirm(uint64 guid); void Player::ResetPetTalents(); void Player::SetVirtualItemSlot(uint8 i, Item* item); void Player::SetSheath(SheathState sheathed); uint8 Player::FindEquipSlot(ItemTemplate const* proto, uint32 slot, bool swap); InventoryResult Player::CanUnequipItems(uint32 item, uint32 count); uint32 Player::GetItemCount(uint32 item, bool inBankAlso, Item* skipItem); uint32 Player::GetItemCountWithLimitCategory(uint32 limitCategory, Item* skipItem); Item* Player::GetItemByGuid(uint64 guid); Item* Player::GetItemByPos(uint16 pos); Item* Player::GetItemByPos(uint8 bag, uint8 slot); Bag* Player::GetBagByPos(uint8 bag); Item* Player::GetWeaponForAttack(WeaponAttackType attackType, bool useable /*= false*/); Item* Player::GetShield(bool useable); uint8 Player::GetAttackBySlot(uint8 slot); bool Player::IsInventoryPos(uint8 bag, uint8 slot); bool Player::IsEquipmentPos(uint8 bag, uint8 slot); bool Player::IsBankPos(uint8 bag, uint8 slot); bool Player::IsBagPos(uint16 pos); bool Player::IsValidPos(uint8 bag, uint8 slot, bool explicit_pos); bool Player::HasItemCount(uint32 item, uint32 count, bool inBankAlso); bool Player::HasItemOrGemWithIdEquipped(uint32 item, uint32 count, uint8 except_slot); bool Player::HasItemOrGemWithLimitCategoryEquipped(uint32 limitCategory, uint32 count, uint8 except_slot); InventoryResult Player::CanTakeMoreSimilarItems(uint32 entry, uint32 count, Item* pItem, uint32* no_space_count); InventoryResult Player::CanStoreItem_InSpecificSlot(uint8 bag, uint8 slot, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool swap, Item* pSrcItem); InventoryResult Player::CanStoreItem_InBag(uint8 bag, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool merge, bool non_specialized, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot); InventoryResult Player::CanStoreItem_InInventorySlots(uint8 slot_begin, uint8 slot_end, ItemPosCountVec &dest, ItemTemplate const* pProto, uint32& count, bool merge, Item* pSrcItem, uint8 skip_bag, uint8 skip_slot); InventoryResult Player::CanStoreItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, uint32 entry, uint32 count, Item* pItem, bool swap, uint32* no_space_count); InventoryResult Player::CanStoreItems(Item** pItems, int count); InventoryResult Player::CanEquipNewItem(uint8 slot, uint16 &dest, uint32 item, bool swap); InventoryResult Player::CanEquipItem(uint8 slot, uint16 &dest, Item* pItem, bool swap, bool not_loading); InventoryResult Player::CanUnequipItem(uint16 pos, bool swap); InventoryResult Player::CanBankItem(uint8 bag, uint8 slot, ItemPosCountVec &dest, Item* pItem, bool swap, bool not_loading); InventoryResult Player::CanUseItem(Item* pItem, bool not_loading); InventoryResult Player::CanUseItem(ItemTemplate const* proto); InventoryResult Player::CanRollForItemInLFG(ItemTemplate const* proto, WorldObject const* lootedObject); Item* Player::StoreNewItem(ItemPosCountVec const& dest, uint32 item, bool update, int32 randomPropertyId); Item* Player::StoreNewItem(ItemPosCountVec const& dest, uint32 item, bool update, int32 randomPropertyId, AllowedLooterSet& allowedLooters); Item* Player::StoreItem(ItemPosCountVec const& dest, Item* pItem, bool update); Item* Player::_StoreItem(uint16 pos, Item* pItem, uint32 count, bool clone, bool update); Item* Player::EquipNewItem(uint16 pos, uint32 item, bool update); Item* Player::EquipItem(uint16 pos, Item* pItem, bool update); void Player::QuickEquipItem(uint16 pos, Item* pItem); void Player::SetVisibleItemSlot(uint8 slot, Item* pItem); void Player::VisualizeItem(uint8 slot, Item* pItem); void Player::RemoveItem(uint8 bag, uint8 slot, bool update); void Player::MoveItemFromInventory(uint8 bag, uint8 slot, bool update); void Player::MoveItemToInventory(ItemPosCountVec const& dest, Item* pItem, bool update, bool in_characterInventoryDB); void Player::DestroyItem(uint8 bag, uint8 slot, bool update); void Player::DestroyItemCount(uint32 item, uint32 count, bool update, bool unequip_check); void Player::DestroyZoneLimitedItem(bool update, uint32 new_zone); void Player::DestroyConjuredItems(bool update); Item* Player::GetItemByEntry(uint32 entry); void Player::DestroyItemCount(Item* pItem, uint32 &count, bool update); void Player::SplitItem(uint16 src, uint16 dst, uint32 count); void Player::SwapItem(uint16 src, uint16 dst); void Player::AddItemToBuyBackSlot(Item* pItem); Item* Player::GetItemFromBuyBackSlot(uint32 slot); void Player::RemoveItemFromBuyBackSlot(uint32 slot, bool del); void Player::SendEquipError(InventoryResult msg, Item* pItem, Item* pItem2, uint32 itemid); void Player::SendBuyError(BuyResult msg, Creature* creature, uint32 item, uint32 /*param*/); void Player::SendSellError(SellResult msg, Creature* creature, uint64 guid); void Player::TradeCancel(bool sendback); void Player::UpdateSoulboundTradeItems(); void Player::AddTradeableItem(Item* item); void Player::RemoveTradeableItem(Item* item); void Player::UpdateItemDuration(uint32 time, bool realtimeonly); void Player::UpdateEnchantTime(uint32 time); void Player::AddEnchantmentDurations(Item* item); void Player::RemoveEnchantmentDurations(Item* item); void Player::RemoveArenaEnchantments(EnchantmentSlot slot); void Player::AddEnchantmentDuration(Item* item, EnchantmentSlot slot, uint32 duration); void Player::ApplyReforgeEnchantment(Item* item, bool apply); void Player::ApplyEnchantment(Item* item, bool apply); void Player::ApplyEnchantment(Item* item, EnchantmentSlot slot, bool apply, bool apply_dur, bool ignore_condition); void Player::UpdateSkillEnchantments(uint16 skill_id, uint16 curr_value, uint16 new_value); void Player::SendEnchantmentDurations(); void Player::SendItemDurations(); void Player::SendNewItem(Item* item, uint32 count, bool received, bool created, bool broadcast); void Player::PrepareGossipMenu(WorldObject* source, uint32 menuId /*= 0*/, bool showQuests /*= false*/); void Player::SendPreparedGossip(WorldObject* source); void Player::OnGossipSelect(WorldObject* source, uint32 gossipListId, uint32 menuId); uint32 Player::GetGossipTextId(WorldObject* source); uint32 Player::GetGossipTextId(uint32 menuId, WorldObject* source); uint32 Player::GetDefaultGossipMenuForSource(WorldObject* source); void Player::PrepareQuestMenu(uint64 guid); void Player::SendPreparedQuest(uint64 guid); bool Player::IsActiveQuest(uint32 quest_id); Quest const* Player::GetNextQuest(uint64 guid, Quest const* quest); bool Player::CanSeeStartQuest(Quest const* quest); bool Player::CanTakeQuest(Quest const* quest, bool msg); bool Player::CanAddQuest(Quest const* quest, bool msg); bool Player::CanCompleteQuest(uint32 quest_id); bool Player::CanCompleteRepeatableQuest(Quest const* quest); bool Player::CanRewardQuest(Quest const* quest, bool msg); bool Player::CanRewardQuest(Quest const* quest, uint32 reward, bool msg); void Player::AddQuest(Quest const* quest, Object* questGiver); void Player::CompleteQuest(uint32 quest_id); void Player::IncompleteQuest(uint32 quest_id); void Player::RewardQuest(Quest const* quest, uint32 reward, Object* questGiver, bool announce); void Player::FailQuest(uint32 questId); bool Player::SatisfyQuestSkill(Quest const* qInfo, bool msg); bool Player::SatisfyQuestLevel(Quest const* qInfo, bool msg); bool Player::SatisfyQuestLog(bool msg); bool Player::SatisfyQuestPreviousQuest(Quest const* qInfo, bool msg); bool Player::SatisfyQuestClass(Quest const* qInfo, bool msg); bool Player::SatisfyQuestRace(Quest const* qInfo, bool msg); bool Player::SatisfyQuestReputation(Quest const* qInfo, bool msg); bool Player::SatisfyQuestStatus(Quest const* qInfo, bool msg); bool Player::SatisfyQuestConditions(Quest const* qInfo, bool msg); bool Player::SatisfyQuestTimed(Quest const* qInfo, bool msg); bool Player::SatisfyQuestExclusiveGroup(Quest const* qInfo, bool msg); bool Player::SatisfyQuestNextChain(Quest const* qInfo, bool msg); bool Player::SatisfyQuestPrevChain(Quest const* qInfo, bool msg); bool Player::SatisfyQuestDay(Quest const* qInfo, bool msg); bool Player::SatisfyQuestWeek(Quest const* qInfo, bool /*msg*/); bool Player::SatisfyQuestSeasonal(Quest const* qInfo, bool /*msg*/); bool Player::SatisfyQuestMonth(Quest const* qInfo, bool /*msg*/); bool Player::GiveQuestSourceItem(Quest const* quest); bool Player::TakeQuestSourceItem(uint32 questId, bool msg); bool Player::GetQuestRewardStatus(uint32 quest_id); QuestStatus Player::GetQuestStatus(uint32 quest_id); bool Player::CanShareQuest(uint32 quest_id); void Player::SetQuestStatus(uint32 quest_id, QuestStatus status); void Player::RemoveActiveQuest(uint32 quest_id); void Player::RemoveRewardedQuest(uint32 quest_id); uint16 Player::GetReqKillOrCastCurrentCount(uint32 quest_id, int32 entry); void Player::AdjustQuestReqItemCount(Quest const* quest, QuestStatusData& questStatusData); uint16 Player::FindQuestSlot(uint32 quest_id); void Player::AreaExploredOrEventHappens(uint32 questId); void Player::GroupEventHappens(uint32 questId, WorldObject const* pEventObject); void Player::ItemAddedQuestCheck(uint32 entry, uint32 count); void Player::ItemRemovedQuestCheck(uint32 entry, uint32 count); void Player::KilledMonster(CreatureTemplate const* cInfo, uint64 guid); void Player::KilledMonsterCredit(uint32 entry, uint64 guid); void Player::KilledPlayerCredit(); void Player::CastedCreatureOrGO(uint32 entry, uint64 guid, uint32 spell_id); void Player::TalkedToCreature(uint32 entry, uint64 guid); void Player::MoneyChanged(uint32 count); void Player::ReputationChanged(FactionEntry const* factionEntry); void Player::ReputationChanged2(FactionEntry const* factionEntry); bool Player::HasQuestForItem(uint32 itemid); void Player::SendQuestComplete(Quest const* quest); void Player::SendQuestReward(Quest const* quest, uint32 XP, Object* questGiver); void Player::SendQuestFailed(uint32 questId, InventoryResult reason); void Player::SendQuestTimerFailed(uint32 quest_id); void Player::SendCanTakeQuestResponse(uint32 msg); void Player::SendQuestConfirmAccept(const Quest* quest, Player* pReceiver); void Player::SendPushToPartyResponse(Player* player, uint32 msg); void Player::SendQuestUpdateAddCreatureOrGo(Quest const* quest, uint64 guid, uint32 creatureOrGO_idx, uint16 old_count, uint16 add_count); void Player::SendQuestUpdateAddPlayer(Quest const* quest, uint16 old_count, uint16 add_count); void Player::Initialize(uint32 guid); void Player::_LoadDeclinedNames(PreparedQueryResult result); void Player::_LoadArenaTeamInfo(PreparedQueryResult result); void Player::_LoadEquipmentSets(PreparedQueryResult result); void Player::_LoadBGData(PreparedQueryResult result); bool Player::LoadPositionFromDB(uint32& mapid, float& x, float& y, float& z, float& o, bool& in_flight, uint64 guid); void Player::SetHomebind(WorldLocation const& /*loc*/, uint32 /*area_id*/); uint32 Player::GetUInt32ValueFromArray(Tokenizer const& data, uint16 index); float Player::GetFloatValueFromArray(Tokenizer const& data, uint16 index); bool Player::isBeingLoaded(); void Player::_LoadCUFProfiles(PreparedQueryResult result); bool Player::isAllowedToLoot(const Creature* creature); void Player::_LoadActions(PreparedQueryResult result); void Player::_LoadAuras(PreparedQueryResult result, uint32 timediff); void Player::_LoadGlyphAuras(); void Player::LoadCorpse(); void Player::_LoadInventory(PreparedQueryResult result, uint32 timeDiff); void Player::_LoadVoidStorage(PreparedQueryResult result); Item* Player::_LoadItem(SQLTransaction& trans, uint32 zoneId, uint32 timeDiff, Field* fields); void Player::_LoadMailedItems(Mail* mail); void Player::_LoadMailInit(PreparedQueryResult resultUnread, PreparedQueryResult resultDelivery); void Player::_LoadMail(); void Player::LoadPet(); void Player::_LoadQuestStatus(PreparedQueryResult result); void Player::_LoadQuestStatusRewarded(PreparedQueryResult result); void Player::_LoadDailyQuestStatus(PreparedQueryResult result); void Player::_LoadWeeklyQuestStatus(PreparedQueryResult result); void Player::_LoadSeasonalQuestStatus(PreparedQueryResult result); void Player::_LoadMonthlyQuestStatus(PreparedQueryResult result); void Player::_LoadSpells(PreparedQueryResult result); void Player::_LoadGroup(PreparedQueryResult result); void Player::_LoadBoundInstances(PreparedQueryResult result); InstancePlayerBind* Player::GetBoundInstance(uint32 mapid, Difficulty difficulty); InstanceSave* Player::GetInstanceSave(uint32 mapid, bool raid); void Player::UnbindInstance(uint32 mapid, Difficulty difficulty, bool unload); void Player::UnbindInstance(BoundInstancesMap::iterator &itr, Difficulty difficulty, bool unload); InstancePlayerBind* Player::BindToInstance(InstanceSave* save, bool permanent, bool load); void Player::BindToInstance(); void Player::SendRaidInfo(); void Player::SendSavedInstances(); void Player::ConvertInstancesToGroup(Player* player, Group* group, bool switchLeader); bool Player::Satisfy(AccessRequirement const* ar, uint32 target_map, bool report); bool Player::CheckInstanceLoginValid(); bool Player::CheckInstanceCount(uint32 instanceId); bool Player::_LoadHomeBind(PreparedQueryResult result); void Player::SaveToDB(bool create /*=false*/); void Player::SaveInventoryAndGoldToDB(SQLTransaction& trans); void Player::SaveGoldToDB(SQLTransaction& trans); void Player::_SaveActions(SQLTransaction& trans); void Player::_SaveAuras(SQLTransaction& trans); void Player::_SaveInventory(SQLTransaction& trans); void Player::_SaveVoidStorage(SQLTransaction& trans); void Player::_SaveCUFProfiles(SQLTransaction& trans); void Player::_SaveMail(SQLTransaction& trans); void Player::_SaveQuestStatus(SQLTransaction& trans); void Player::_SaveDailyQuestStatus(SQLTransaction& trans); void Player::_SaveWeeklyQuestStatus(SQLTransaction& trans); void Player::_SaveSeasonalQuestStatus(SQLTransaction& trans); void Player::_SaveMonthlyQuestStatus(SQLTransaction& trans); void Player::_SaveSkills(SQLTransaction& trans); void Player::_SaveSpells(SQLTransaction& trans); void Player::_SaveStats(SQLTransaction& trans); void Player::outDebugValues(); void Player::UpdateSpeakTime(); bool Player::CanSpeak(); void Player::SendAttackSwingNotInRange(); void Player::SavePositionInDB(uint32 mapid, float x, float y, float z, float o, uint32 zone, uint64 guid); void Player::SetUInt32ValueInArray(Tokenizer& Tokenizer, uint16 index, uint32 value); void Player::Customize(uint64 guid, uint8 gender, uint8 skin, uint8 face, uint8 hairStyle, uint8 hairColor, uint8 facialHair); void Player::SendAttackSwingDeadTarget(); void Player::SendAttackSwingCantAttack(); void Player::SendAttackSwingCancelAttack(); void Player::SendAttackSwingBadFacingAttack(); void Player::SendAutoRepeatCancel(Unit* target); void Player::SendExplorationExperience(uint32 Area, uint32 Experience); void Player::SendDungeonDifficulty(bool IsInGroup); void Player::SendRaidDifficulty(bool IsInGroup, int32 forcedDifficulty); void Player::SendResetFailedNotify(uint32 mapid); void Player::ResetInstances(uint8 method, bool isRaid); void Player::SendResetInstanceSuccess(uint32 MapId); void Player::SendResetInstanceFailed(uint32 reason, uint32 MapId); void Player::UpdateAfkReport(time_t currTime); void Player::UpdateContestedPvP(uint32 diff); void Player::UpdatePvPFlag(time_t currTime); void Player::UpdateDuelFlag(time_t currTime); Pet* Player::GetPet(); void Player::RemovePet(Pet* pet, PetSaveMode mode, bool returnreagent); void Player::StopCastingCharm(); inline void Player::BuildPlayerChat(WorldPacket* data, uint8 msgtype, const std::string& text, uint32 language, const char* addonPrefix /*= NULL*/); void Player::Say(const std::string& text, const uint32 language); void Player::Yell(const std::string& text, const uint32 language); void Player::TextEmote(const std::string& text); void Player::WhisperAddon(const std::string& text, const std::string& prefix, Player* receiver); void Player::Whisper(const std::string& text, uint32 language, uint64 receiver); void Player::PetSpellInitialize(); void Player::PossessSpellInitialize(); void Player::VehicleSpellInitialize(); void Player::CharmSpellInitialize(); void Player::SendRemoveControlBar(); bool Player::IsAffectedBySpellmod(SpellInfo const* spellInfo, SpellModifier* mod, Spell* spell); void Player::AddSpellMod(SpellModifier* mod, bool apply); void Player::RestoreSpellMods(Spell* spell, uint32 ownerAuraId, Aura* aura); void Player::RestoreAllSpellMods(uint32 ownerAuraId, Aura* aura); void Player::RemoveSpellMods(Spell* spell); void Player::DropModCharge(SpellModifier* mod, Spell* spell); void Player::SetSpellModTakingSpell(Spell* spell, bool apply); void Player::SendProficiency(ItemClass itemClass, uint32 itemSubclassMask); void Player::RemovePetitionsAndSigns(uint64 guid, uint32 type); void Player::LeaveAllArenaTeams(uint64 guid); uint32 Player::GetRBGPersonalRating(); void Player::SetRestBonus (float rest_bonus_new); bool Player::ActivateTaxiPathTo(std::vector<uint32> const& nodes, Creature* npc /*= NULL*/, uint32 spellid /*= 0*/); bool Player::ActivateTaxiPathTo(uint32 taxi_path_id, uint32 spellid /*= 0*/); void Player::CleanupAfterTaxiFlight(); void Player::ContinueTaxiFlight(); void Player::ProhibitSpellSchool(SpellSchoolMask idSchoolMask, uint32 unTimeMs); void Player::InitDataForForm(bool reapplyMods); void Player::InitDisplayIds(); inline bool Player::_StoreOrEquipNewItem(uint32 vendorslot, uint32 item, uint8 count, uint8 bag, uint8 slot, int32 price, ItemTemplate const *pProto, Creature *pVendor, VendorItem const* crItem, bool bStore); bool Player::BuyCurrencyFromVendorSlot(uint64 vendorGuid, uint32 vendorSlot, uint32 currency, uint32 count); bool Player::BuyItemFromVendorSlot(uint64 vendorguid, uint32 vendorslot, uint32 item, uint8 count, uint8 bag, uint8 slot); uint32 Player::GetMaxPersonalArenaRatingRequirement(uint32 minarenaslot); void Player::UpdateHomebindTime(uint32 time); void Player::UpdatePvPState(bool onlyFFA); void Player::UpdatePvP(bool state, bool override); void Player::AddSpellAndCategoryCooldowns(SpellInfo const* spellInfo, uint32 itemId, Spell* spell, bool infinityCooldown); void Player::AddSpellCooldown(uint32 spellid, uint32 itemid, time_t end_time); void Player::SendCooldownEvent(SpellInfo const* spellInfo, uint32 itemId /*= 0*/, Spell* spell /*= NULL*/, bool setCooldown /*= true*/); void Player::UpdatePotionCooldown(Spell* spell); bool Player::EnchantmentFitsRequirements(uint32 enchantmentcondition, int8 slot); void Player::CorrectMetaGemEnchants(uint8 exceptslot, bool apply); void Player::ToggleMetaGemsActive(uint8 exceptslot, bool apply); void Player::SetBattlegroundEntryPoint(); void Player::LeaveBattleground(bool teleportToEntryPoint); bool Player::CanJoinToBattleground(); bool Player::CanReportAfkDueToLimit(); void Player::ReportedAfkBy(Player* reporter); WorldLocation Player::GetStartPosition(); bool Player::IsNeverVisible(); bool Player::CanAlwaysSee(WorldObject const* obj); bool Player::IsAlwaysDetectableFor(WorldObject const* seer); bool Player::IsVisibleGloballyFor(Player const* u); inline void UpdateVisibilityOf_helper(std::set<uint64>& s64, T* target, std::set<Unit*>& /*v*/); inline void UpdateVisibilityOf_helper(std::set<uint64>& s64, GameObject* target, std::set<Unit*>& /*v*/); inline void UpdateVisibilityOf_helper(std::set<uint64>& s64, Creature* target, std::set<Unit*>& v); inline void UpdateVisibilityOf_helper(std::set<uint64>& s64, Player* target, std::set<Unit*>& v); inline void BeforeVisibilityDestroy(T* /*t*/, Player* /*p*/); inline void BeforeVisibilityDestroy<Creature>(Creature* t, Player* p); void Player::UpdateVisibilityOf(WorldObject* target); void Player::UpdateTriggerVisibility(); void Player::SendInitialVisiblePackets(Unit* target); void Player::UpdateVisibilityOf(T* target, UpdateData& data, std::set<Unit*>& visibleNow); void Player::UpdateObjectVisibility(bool forced); void Player::UpdateVisibilityForPlayer(); void Player::InitPrimaryProfessions(); void Player::ModifyMoney(int64 d); Unit* Player::GetSelectedUnit(); Player* Player::GetSelectedPlayer(); void Player::SendComboPoints(); void Player::AddComboPoints(Unit* target, int8 count, Spell* spell); void Player::GainSpellComboPoints(int8 count); void Player::ClearComboPoints(); void Player::SetGroup(Group* group, int8 subgroup); void Player::SendInitialPacketsBeforeAddToMap(); void Player::SendInitialPacketsAfterAddToMap(); void Player::SendUpdateToOutOfRangeGroupMembers(); void Player::SendTransferAborted(uint32 mapid, TransferAbortReason reason, uint8 arg); void Player::SendInstanceResetWarning(uint32 mapid, Difficulty difficulty, uint32 time); void Player::ApplyEquipCooldown(Item* pItem); void Player::resetSpells(bool myClassOnly); void Player::learnDefaultSpells(); void Player::learnQuestRewardedSpells(Quest const* quest); void Player::learnQuestRewardedSpells(); void Player::learnSkillRewardedSpells(uint32 skill_id, uint32 skill_value); void Player::SendAurasForTarget(Unit* target); void Player::SetDailyQuestStatus(uint32 quest_id); void Player::SetWeeklyQuestStatus(uint32 quest_id); void Player::SetSeasonalQuestStatus(uint32 quest_id); void Player::SetMonthlyQuestStatus(uint32 quest_id); void Player::ResetDailyQuestStatus(); void Player::ResetWeeklyQuestStatus(); void Player::ResetSeasonalQuestStatus(uint16 event_id); void Player::ResetMonthlyQuestStatus(); Battleground* Player::GetBattleground(); bool Player::InArena(); bool Player::GetBGAccessByLevel(BattlegroundTypeId bgTypeId); float Player::GetReputationPriceDiscount(Creature const* creature); bool Player::IsSpellFitByClassAndRace(uint32 spell_id); bool Player::HasQuestForGO(int32 GOId); void Player::UpdateForQuestWorldObjects(); void Player::SummonIfPossible(bool agree); void Player::RemoveItemDurations(Item* item); void Player::AddItemDurations(Item* item); void Player::AutoUnequipOffhandIfNeed(bool force /*= false*/); OutdoorPvP* Player::GetOutdoorPvP(); bool Player::HasItemFitToSpellRequirements(SpellInfo const* spellInfo, Item const* ignoreItem); bool Player::CanNoReagentCast(SpellInfo const* spellInfo); void Player::RemoveItemDependentAurasAndCasts(Item* pItem); uint32 Player::GetResurrectionSpellId(); bool Player::isHonorOrXPTarget(Unit const *victim); bool Player::GetsRecruitAFriendBonus(bool forXP); void Player::RewardPlayerAndGroupAtKill(Unit* victim, bool isBattleGround); void Player::RewardPlayerAndGroupAtEvent(uint32 creature_id, WorldObject* pRewardSource); bool Player::IsAtGroupRewardDistance(WorldObject const* pRewardSource); bool Player::IsAtRecruitAFriendDistance(WorldObject const* pOther); void Player::ResurectUsingRequestData(); void Player::SetClientControl(Unit* target, uint8 allowMove); void Player::UpdateZoneDependentAuras(uint32 newZone); void Player::UpdateAreaDependentAuras(uint32 newArea); uint32 Player::GetCorpseReclaimDelay(bool pvp); void Player::UpdateCorpseReclaimDelay(); void Player::SendCorpseReclaimDelay(bool load); Player* Player::GetNextRandomRaidMember(float radius); PartyResult Player::CanUninviteFromGroup(); bool Player::isUsingLfg(); bool Player::inRandomLfgDungeon(); void Player::SetBattlegroundOrBattlefieldRaid(Group* group, int8 subgroup); void Player::RemoveFromBattlegroundOrBattlefieldRaid(); void Player::SetOriginalGroup(Group* group, int8 subgroup); void Player::UpdateUnderwaterState(Map* m, float x, float y, float z); void Player::SetCanParry(bool value); void Player::SetCanBlock(bool value); bool ItemPosCount::isContainedIn(ItemPosCountVec const& vec); void Player::StopCastingBindSight(); void Player::SetViewpoint(WorldObject* target, bool apply); WorldObject* Player::GetViewpoint(); bool Player::CanUseBattlegroundObject(GameObject* gameobject); bool Player::CanCaptureTowerPoint(); uint32 Player::GetBarberShopCost(uint8 newhairstyle, uint8 newhaircolor, uint8 newfacialhair, BarberShopStyleEntry const* newSkin); void Player::InitGlyphsForLevel(); bool Player::isTotalImmune(); bool Player::HasTitle(uint32 bitIndex); void Player::SetTitle(CharTitlesEntry const* title, bool lost); bool Player::isTotalImmunity(); void Player::UpdateCharmedAI(); uint32 Player::GetRuneTypeBaseCooldown(RuneType runeType); void Player::RemoveRunesByAuraEffect(AuraEffect const* aura); void Player::RestoreBaseRune(uint8 index); void Player::ConvertRune(uint8 index, RuneType newType); void Player::ResyncRunes(uint8 count); void Player::AddRunePower(uint8 index); void Player::InitRunes(); bool Player::IsBaseRuneSlotsOnCooldown(RuneType runeType); void Player::AutoStoreLoot(uint8 bag, uint8 slot, uint32 loot_id, LootStore const& store, bool broadcast); void Player::StoreLootItem(uint8 lootSlot, Loot* loot); uint32 Player::CalculateTalentsPoints(); bool Player::IsKnowHowFlyIn(uint32 mapid, uint32 zone); void Player::learnSpellHighRank(uint32 spellid); void Player::_LoadSkills(PreparedQueryResult result); InventoryResult Player::CanEquipUniqueItem(Item* pItem, uint8 eslot, uint32 limit_count); InventoryResult Player::CanEquipUniqueItem(ItemTemplate const* itemProto, uint8 except_slot, uint32 limit_count); void Player::HandleFall(MovementInfo const& movementInfo); void Player::ResetAchievements(); void Player::SendRespondInspectAchievements(Player* player); uint32 Player::GetAchievementPoints(); bool Player::HasAchieved(uint32 achievementId); void Player::StartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry, uint32 timeLost/* = 0*/); void Player::RemoveTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry); void Player::ResetAchievementCriteria(AchievementCriteriaTypes type, uint64 miscValue1 /*= 0*/, uint64 miscValue2 /*= 0*/, bool evenIfCriteriaComplete /* = false*/); void Player::UpdateAchievementCriteria(AchievementCriteriaTypes type, uint64 miscValue1 /*= 0*/, uint64 miscValue2 /*= 0*/, uint64 miscValue3 /*= 0*/, Unit* unit /*= NULL*/); void Player::CompletedAchievement(AchievementEntry const* entry); bool Player::LearnTalent(uint32 talentId, uint32 talentRank); void Player::LearnPetTalent(uint64 petGuid, uint32 talentId, uint32 talentRank); void Player::AddKnownCurrency(uint32 itemId); void Player::UpdateFallInformationIfNeed(MovementInfo const& minfo, uint16 opcode); void Player::UnsummonPetTemporaryIfAny(); void Player::ResummonPetTemporaryUnSummonedIfAny(); bool Player::canSeeSpellClickOn(Creature const* c); void Player::BuildPlayerTalentsInfoData(WorldPacket* data); void Player::BuildPetTalentsInfoData(WorldPacket* data); void Player::SendTalentsInfoData(bool pet); void Player::BuildEnchantmentsInfoData(WorldPacket* data); void Player::SendEquipmentSetList(); void Player::SetEquipmentSet(uint32 index, EquipmentSet eqset); void Player::_SaveEquipmentSets(SQLTransaction& trans); void Player::_SaveBGData(SQLTransaction& trans); void Player::DeleteEquipmentSet(uint64 setGuid); void Player::RemoveAtLoginFlag(AtLoginFlags flags, bool persist /*= false*/); void Player::SendClearCooldown(uint32 spell_id, Unit* target); void Player::SendClearAllCooldowns(Unit* target); void Player::ResetMap(); void Player::SetMap(Map* map); void Player::_LoadGlyphs(PreparedQueryResult result); void Player::_SaveGlyphs(SQLTransaction& trans); void Player::_LoadTalents(PreparedQueryResult result); void Player::_SaveTalents(SQLTransaction& trans); void Player::UpdateSpecCount(uint8 count); void Player::ActivateSpec(uint8 spec); void Player::ResetTimeSync(); void Player::SendTimeSync(); void Player::SetReputation(uint32 factionentry, uint32 value); uint32 Player::GetReputation(uint32 factionentry); std::string Player::GetGuildName(); void Player::SendDuelCountdown(uint32 counter); void Player::AddRefundReference(uint32 it); void Player::DeleteRefundReference(uint32 it); void Player::SendRefundInfo(Item* item); bool Player::AddItem(uint32 itemId, uint32 count); void Player::SendItemRefundResult(Item* item, ItemExtendedCostEntry const* iece, uint8 error); void Player::RefundItem(Item* item); void Player::SetRandomWinner(bool isWinner); void Player::_LoadRandomBGStatus(PreparedQueryResult result); float Player::GetAverageItemLevel(); void Player::_LoadInstanceTimeRestrictions(PreparedQueryResult result); void Player::_SaveInstanceTimeRestrictions(SQLTransaction& trans); bool Player::IsInWhisperWhiteList(uint64 guid); uint8 Player::GetNextVoidStorageFreeSlot(); uint8 Player::GetNumOfVoidStorageFreeSlots(); uint8 Player::AddVoidStorageItem(const VoidStorageItem& item); void Player::AddVoidStorageItemAtSlot(uint8 slot, const VoidStorageItem& item); void Player::DeleteVoidStorageItem(uint8 slot); bool Player::SwapVoidStorageItem(uint8 oldSlot, uint8 newSlot); VoidStorageItem* Player::GetVoidStorageItem(uint8 slot); VoidStorageItem* Player::GetVoidStorageItem(uint64 id, uint8& slot); void Player::SendMovementSetCanFly(bool apply); void Player::SendMovementSetCanTransitionBetweenSwimAndFly(bool apply); void Player::SendMovementSetHover(bool apply); void Player::SendMovementSetWaterWalking(bool apply); void Player::SendMovementSetFeatherFall(bool apply); void Player::SendMovementSetCollisionHeight(float height); Guild* Player::GetGuild(); Pet* Player::SummonPet(uint32 entry, float x, float y, float z, float ang, PetType petType, uint32 duration);

337595dff3db1e2c0698cd18057553de4ffbe8eee7b2ec58f729a33f81f46984

blorenz

phantomjs

src/qt/src/3rdparty/webkit/Source/WebKit/qt/Api/qwebpage.cpp

QWebPagePrivateDebugger::callEvent

void QWebPagePrivateDebugger::callEvent(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber) { stepIn(frame, sourceID, lineNumber); }

const char* QWebPagePrivate::editorCommandForWebActions(QWebPage::WebAction action); static inline DragOperation dropActionToDragOp(Qt::DropActions actions); static inline Qt::DropAction dragOpToDropAction(unsigned actions); QWebPagePrivateDebugger::QWebPagePrivateDebugger(QWebPage* page); QWebPagePrivateDebugger::~QWebPagePrivateDebugger(); void QWebPagePrivateDebugger::detach(JSC::JSGlobalObject*); void QWebPagePrivateDebugger::sourceParsed(JSC::ExecState*, JSC::SourceProvider*, int errorLineNumber, const JSC::UString& errorMessage); void QWebPagePrivateDebugger::exception(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber, bool hasHandler); void QWebPagePrivateDebugger::reportError(const JSC::JSValue& exception); void QWebPagePrivateDebugger::atStatement(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::returnEvent(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::willExecuteProgram(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::didExecuteProgram(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::didReachBreakpoint(const JSC::DebuggerCallFrame&, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::stepIn(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::stepOver(const JSC::DebuggerCallFrame& frame, intptr_t sourceID, int lineNumber); void QWebPagePrivateDebugger::stepOut(const JSC::DebuggerCallFrame& frame); QWebPagePrivate::QWebPagePrivate(QWebPage *qq); QWebPagePrivate::~QWebPagePrivate(); WebCore::ViewportArguments QWebPagePrivate::viewportArguments(); WebCore::Page* QWebPagePrivate::core(const QWebPage* page); QWebPagePrivate* QWebPagePrivate::priv(QWebPage* page); bool QWebPagePrivate::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, QWebPage::NavigationType type); void QWebPagePrivate::createMainFrame(); static QWebPage::WebAction webActionForContextMenuAction(WebCore::ContextMenuAction action); void QWebPagePrivate::_q_webActionTriggered(bool checked); void QWebPagePrivate::_q_cleanupLeakMessages(); void QWebPagePrivate::updateAction(QWebPage::WebAction action); void QWebPagePrivate::updateNavigationActions(); void QWebPagePrivate::updateEditorActions(); void QWebPagePrivate::timerEvent(QTimerEvent *ev); void QWebPagePrivate::mouseMoveEvent(T* ev); void QWebPagePrivate::mousePressEvent(T* ev); void QWebPagePrivate::mouseDoubleClickEvent(T *ev); void QWebPagePrivate::mouseTripleClickEvent(T *ev); void QWebPagePrivate::handleClipboard(QEvent* ev, Qt::MouseButton button); void QWebPagePrivate::mouseReleaseEvent(T *ev); void QWebPagePrivate::handleSoftwareInputPanel(Qt::MouseButton button, const QPoint& pos); void QWebPagePrivate::contextMenuEvent(const QPoint& globalPos); QMenu *QWebPage::createStandardContextMenu(); void QWebPagePrivate::wheelEvent(T *ev); QWebPage::WebAction QWebPagePrivate::editorActionForKeyEvent(QKeyEvent* event); void QWebPagePrivate::keyPressEvent(QKeyEvent *ev); void QWebPagePrivate::keyReleaseEvent(QKeyEvent *ev); void QWebPagePrivate::focusInEvent(QFocusEvent*); void QWebPagePrivate::focusOutEvent(QFocusEvent*); void QWebPagePrivate::dragEnterEvent(T* ev); void QWebPagePrivate::dragLeaveEvent(T *ev); void QWebPagePrivate::dragMoveEvent(T *ev); void QWebPagePrivate::dropEvent(T *ev); void QWebPagePrivate::leaveEvent(QEvent*); void QWebPage::setPalette(const QPalette &pal); QPalette QWebPage::palette(); void QWebPagePrivate::inputMethodEvent(QInputMethodEvent *ev); void QWebPagePrivate::dynamicPropertyChangeEvent(QDynamicPropertyChangeEvent* event); void QWebPagePrivate::shortcutOverrideEvent(QKeyEvent* event); bool QWebPagePrivate::handleScrolling(QKeyEvent *ev, Frame *frame); void QWebPagePrivate::adjustPointForClicking(QMouseEvent*); void QWebPagePrivate::adjustPointForClicking(QGraphicsSceneMouseEvent* ev); bool QWebPagePrivate::touchEvent(QTouchEvent* event); QVariant QWebPage::inputMethodQuery(Qt::InputMethodQuery property); void QWebPagePrivate::setInspector(QWebInspector* insp); QWebInspector* QWebPagePrivate::getOrCreateInspector(); InspectorController* QWebPagePrivate::inspectorController(); quint16 QWebPagePrivate::inspectorServerPort(); static bool hasMouseListener(Element* element); static bool isClickableElement(Element* element, RefPtr<NodeList> list); static bool isValidFrameOwner(Element* element); static Element* nodeToElement(Node* node); QWebPagePrivate::TouchAdjuster::TouchAdjuster(unsigned topPadding, unsigned rightPadding, unsigned bottomPadding, unsigned leftPadding); IntPoint QWebPagePrivate::TouchAdjuster::findCandidatePointForTouch(const IntPoint& touchPoint, Document* document); QWebPage::ViewportAttributes::ViewportAttributes(); QWebPage::ViewportAttributes::ViewportAttributes(const QWebPage::ViewportAttributes& other); QWebPage::ViewportAttributes::~ViewportAttributes(); QWebPage::ViewportAttributes& QWebPage::ViewportAttributes::operator=(const QWebPage::ViewportAttributes& other); QWebPage::QWebPage(QObject *parent); QWebPage::~QWebPage(); QWebFrame *QWebPage::mainFrame(); QWebFrame *QWebPage::currentFrame(); QWebFrame* QWebPage::frameAt(const QPoint& pos); QWebHistory *QWebPage::history(); void QWebPage::setView(QWidget* view); QWidget *QWebPage::view(); void QWebPage::javaScriptConsoleMessage(const QString& message, int lineNumber, const QString& sourceID); void QWebPage::javaScriptAlert(QWebFrame *frame, const QString& msg); bool QWebPage::javaScriptConfirm(QWebFrame *frame, const QString& msg); bool QWebPage::javaScriptPrompt(QWebFrame *frame, const QString& msg, const QString& defaultValue, QString* result); bool QWebPage::shouldInterruptJavaScript(); void QWebPage::setFeaturePermission(QWebFrame* frame, Feature feature, PermissionPolicy policy); QWebPage *QWebPage::createWindow(WebWindowType type); QObject *QWebPage::createPlugin(const QString &classid, const QUrl &url, const QStringList &paramNames, const QStringList &paramValues); static void extractContentTypeFromHash(const HashSet<String>& types, QStringList* list); static void extractContentTypeFromPluginVector(const Vector<PluginPackage*>& plugins, QStringList* list); QStringList QWebPage::supportedContentTypes(); bool QWebPage::supportsContentType(const QString& mimeType); static WebCore::FrameLoadRequest frameLoadRequest(const QUrl &url, WebCore::Frame *frame); static void openNewWindow(const QUrl& url, WebCore::Frame* frame); static void collectChildFrames(QWebFrame* frame, QList<QWebFrame*>& list); void QWebPage::triggerAction(WebAction action, bool); QSize QWebPage::viewportSize(); void QWebPage::setViewportSize(const QSize &size); static int getintenv(const char* variable); static QSize queryDeviceSizeForScreenContainingWidget(const QWidget* widget); QWebPage::ViewportAttributes QWebPage::viewportAttributesForSize(const QSize& availableSize); QSize QWebPage::preferredContentsSize(); void QWebPage::setPreferredContentsSize(const QSize& size); void QWebPage::setActualVisibleContentRect(const QRect& rect); bool QWebPage::acceptNavigationRequest(QWebFrame *frame, const QNetworkRequest &request, QWebPage::NavigationType type); bool QWebPage::hasSelection(); QString QWebPage::selectedText(); QString QWebPage::selectedHtml(); QAction *QWebPage::action(WebAction action); bool QWebPage::isModified(); QUndoStack *QWebPage::undoStack(); bool QWebPage::event(QEvent *ev); bool QWebPage::focusNextPrevChild(bool next); void QWebPage::setContentEditable(bool editable); bool QWebPage::isContentEditable(); void QWebPage::setForwardUnsupportedContent(bool forward); bool QWebPage::forwardUnsupportedContent(); void QWebPage::setLinkDelegationPolicy(LinkDelegationPolicy policy); QWebPage::LinkDelegationPolicy QWebPage::linkDelegationPolicy(); bool QWebPage::swallowContextMenuEvent(QContextMenuEvent *event); void QWebPage::updatePositionDependentActions(const QPoint &pos); bool QWebPage::extension(Extension extension, const ExtensionOption *option, ExtensionReturn *output); bool QWebPage::supportsExtension(Extension extension); bool QWebPage::findText(const QString &subString, FindFlags options); QWebSettings *QWebPage::settings(); QString QWebPage::chooseFile(QWebFrame *parentFrame, const QString& suggestedFile); void QWebPage::setNetworkAccessManager(QNetworkAccessManager *manager); QNetworkAccessManager *QWebPage::networkAccessManager(); void QWebPage::setPluginFactory(QWebPluginFactory *factory); QWebPluginFactory *QWebPage::pluginFactory(); QString QWebPage::userAgentForUrl(const QUrl&); void QWebPagePrivate::_q_onLoadProgressChanged(int); quint64 QWebPage::totalBytes(); quint64 QWebPage::bytesReceived();

3d5422e5d9cdd9b3b103e2f907eb8608234272300312a8e5848e94152d68f7a5

bluescan

tacent

UnitTests/Src/TestFoundation.cpp

tTestUnit

tTestUnit(UTF) { tPrintf("Testing conversions between UTF encodings.\n"); const char8_t* utf8src = u8"wΔ𝒞\n" "I refuse to prove that I exist for proof denies faith and without faith I am nothing.\n" "Ah, but the Babel fish proves you exist, therefore you don't.\n" "And here are some Unicode characters: wΔ𝒞 (the third should look similar to a C)\n" "w is ASCII, Δ is in the Basic Multilingual Plane, and 𝒞 is in an Astral plane."; int length16 = tStd::tUTF16s(nullptr, utf8src); tPrintf("%d char16 codeunits are needed for the UTF-16 encoding of:\n%s\n", length16, utf8src); char16_t* utf16str = new char16_t[length16+1]; tStd::tUTF16s(utf16str, utf8src); const char* wfilename16 = "TestData/UTF/WrittenUTF16.txt"; tPrintf("Writing UTF-16 string to %s\n", wfilename16); tCreateFile(wfilename16, utf16str, length16, true); const char* rfilename16 = "TestData/UTF/UTF16.txt"; tRequire(tSystem::tFilesIdentical(wfilename16, rfilename16)); int length8 = tStd::tUTF8s(nullptr, utf16str); tPrintf("%d char8 codeunits are needed for the UTF-8 encoding.\n", length8); char8_t* utf8str = new char8_t[length8+1]; tStd::tUTF8s(utf8str, utf16str); const char* wfilename8 = "TestData/UTF/WrittenUTF8.txt"; tPrintf("Writing UTF-8 string to %s\n", wfilename8); tCreateFile(wfilename8, utf8str, length8, false); const char* rfilename8 = "TestData/UTF/UTF8.txt"; tRequire(tSystem::tFilesIdentical(wfilename8, rfilename8)); int length32 = tStd::tUTF32s(nullptr, utf8src); tPrintf("%d char32 codeunits are needed for the UTF-32 encoding.\n", length32); char32_t* utf32str = new char32_t[length32+1]; tStd::tUTF32s(utf32str, utf8src); const char* wfilename32 = "TestData/UTF/WrittenUTF32.txt"; tPrintf("Writing UTF-32 string to %s\n", wfilename32); tCreateFile(wfilename32, utf32str, length32, true); const char* rfilename32 = "TestData/UTF/UTF32.txt"; tRequire(tSystem::tFilesIdentical(wfilename32, rfilename32)); delete[] utf8str; delete[] utf16str; delete[] utf32str; tString testUTF16AndBack(u8"wΔ𝒞 went from UTF-8 to UTF-16 and back to UTF-8"); tString orig16 = testUTF16AndBack; int len16 = testUTF16AndBack.GetUTF16(nullptr); utf16str = new char16_t[len16]; testUTF16AndBack.GetUTF16(utf16str); testUTF16AndBack.SetUTF16(utf16str); tRequire(testUTF16AndBack == orig16); tPrintf("%s\n", testUTF16AndBack.Chr()); const char* wfilename8A = "TestData/UTF/WrittenUTF8_UTF16_UTF8.txt"; tCreateFile(wfilename8A, testUTF16AndBack); tString testUTF32AndBack(u8"wΔ𝒞 went from UTF-8 to UTF-32 and back to UTF-8"); tString orig32 = testUTF32AndBack; int len32 = testUTF32AndBack.GetUTF32(nullptr); utf32str = new char32_t[len32]; testUTF32AndBack.GetUTF32(utf32str); testUTF16AndBack.SetUTF32(utf32str); tRequire(testUTF32AndBack == orig32); tPrintf("%s\n", testUTF32AndBack.Chr()); const char* wfilename8B = "TestData/UTF/WrittenUTF8_UTF32_UTF8.txt"; tCreateFile(wfilename8B, testUTF32AndBack); delete[] utf16str; delete[] utf32str; tString utf8String(utf8src); int numUTF16UnitsNeeded = tStd::tUTF16(nullptr, utf8String.Units(), utf8String.Length()); int numUTF16UnitsNeededStr = tStd::tUTF16s(nullptr, utf8String.Units()); tRequire(numUTF16UnitsNeeded == numUTF16UnitsNeededStr); tStringUTF16 utf16String(utf8String); tRequire(utf16String.Length() == numUTF16UnitsNeeded); tRequire(*(utf16String.Units() + utf16String.Length()) == 0); int numUTF32UnitsNeeded = tStd::tUTF32(nullptr, utf8String.Units(), utf8String.Length()); int numUTF32UnitsNeededStr = tStd::tUTF32s(nullptr, utf8String.Units()); tRequire(numUTF32UnitsNeeded == numUTF32UnitsNeededStr); tStringUTF32 utf32String(utf8String); tRequire(utf32String.Length() == numUTF32UnitsNeeded); tRequire(*(utf32String.Units() + utf32String.Length()) == 0); } tTestUnit(RingBuf

tTestUnit(Types); tTestUnit(Array); bool LessThan(const Item& a, const Item& b); bool LessThanNorm(const NormItem& a, const NormItem& b); void ListAddThreadEvens(); void ListAddThreadOdds(); tTestUnit(List); T* NamedList<T>::FindNodeByName(const tString& name); BigNode(const char* name, const char* dependsOn, bool gen, bool always); bool BigSort(const BigNode& lhs, const BigNode& rhs); tTestUnit(ListExtra); static void PrintMapStats(const tMap<tString, tString>& mp); tTestUnit(Map); std::promise<PromiseObject> GiveMeFloats(); tTestUnit(Promise); tTestUnit(Sort); tTestUnit(BitArray); tTestUnit(BitField); tTestUnit(FixInt); tTestUnit(String); r); ueue); l); const char* testString = "This is the text that is being used for testing hash functions."; tPrintf("%s\n\n", testString); tPrintf("Testing tHalf (half-precision float);

667bf55e5653705765f55c6a2b9c36ec769392645f4ab4feab080cc92c2e744c

Thekla

hlslparser

src/HLSLParser.cpp

HLSLParser::ParseAttributeList

bool HLSLParser::ParseAttributeList(HLSLAttribute*& firstAttribute) { const char* fileName = GetFileName(); int line = GetLineNumber(); HLSLAttribute * lastAttribute = firstAttribute; do { const char * identifier = NULL; if (!ExpectIdentifier(identifier)) { return false; } HLSLAttribute * attribute = m_tree->AddNode<HLSLAttribute>(fileName, line); if (strcmp(identifier, "unroll") == 0) attribute->attributeType = HLSLAttributeType_Unroll; else if (strcmp(identifier, "flatten") == 0) attribute->attributeType = HLSLAttributeType_Flatten; else if (strcmp(identifier, "branch") == 0) attribute->attributeType = HLSLAttributeType_Branch; else if (strcmp(identifier, "nofastmath") == 0) attribute->attributeType = HLSLAttributeType_NoFastMath; if (firstAttribute == NULL) { firstAttribute = attribute; } else { lastAttribute->nextAttribute = attribute; } lastAttribute = attribute; } while(Accept(',')); return true; }

explicit Intrinsic(const char* name, HLSLBaseType returnType); explicit Intrinsic(const char* name, HLSLBaseType returnType, HLSLBaseType arg1); explicit Intrinsic(const char* name, HLSLBaseType returnType, HLSLBaseType arg1, HLSLBaseType arg2); explicit Intrinsic(const char* name, HLSLBaseType returnType, HLSLBaseType arg1, HLSLBaseType arg2, HLSLBaseType arg3); explicit Intrinsic(const char* name, HLSLBaseType returnType, HLSLBaseType arg1, HLSLBaseType arg2, HLSLBaseType arg3, HLSLBaseType arg4); Intrinsic SamplerIntrinsic(const char* name, HLSLBaseType returnType, HLSLBaseType arg1, HLSLBaseType samplerType, HLSLBaseType arg2); static const char* GetTypeName(const HLSLType& type); static const char* GetBinaryOpName(HLSLBinaryOp binaryOp); static int GetTypeCastRank(HLSLTree * tree, const HLSLType& srcType, const HLSLType& dstType); static bool GetFunctionCallCastRanks(HLSLTree* tree, const HLSLFunctionCall* call, const HLSLFunction* function, int* rankBuffer); static CompareFunctionsResult CompareFunctions(HLSLTree* tree, const HLSLFunctionCall* call, const HLSLFunction* function1, const HLSLFunction* function2); static bool GetBinaryOpResultType(HLSLBinaryOp binaryOp, const HLSLType& type1, const HLSLType& type2, HLSLType& result); HLSLParser::HLSLParser(Allocator* allocator, const char* fileName, const char* buffer, size_t length); bool HLSLParser::Accept(int token); bool HLSLParser::Accept(const char* token); bool HLSLParser::Expect(int token); bool HLSLParser::Expect(const char * token); bool HLSLParser::AcceptIdentifier(const char*& identifier); bool HLSLParser::ExpectIdentifier(const char*& identifier); bool HLSLParser::AcceptFloat(float& value); bool HLSLParser::AcceptHalf( float& value ); bool HLSLParser::AcceptInt(int& value); bool HLSLParser::ParseTopLevel(HLSLStatement*& statement); bool HLSLParser::ParseStatementOrBlock(HLSLStatement*& firstStatement, const HLSLType& returnType, bool scoped/*=true*/); bool HLSLParser::ParseBlock(HLSLStatement*& firstStatement, const HLSLType& returnType); bool HLSLParser::ParseStatement(HLSLStatement*& statement, const HLSLType& returnType); bool HLSLParser::ParseDeclaration(HLSLDeclaration*& declaration); bool HLSLParser::ParseDeclarationAssignment(HLSLDeclaration* declaration); bool HLSLParser::ParseFieldDeclaration(HLSLStructField*& field); bool HLSLParser::CheckTypeCast(const HLSLType& srcType, const HLSLType& dstType); bool HLSLParser::ParseExpression(HLSLExpression*& expression); bool HLSLParser::AcceptBinaryOperator(int priority, HLSLBinaryOp& binaryOp); bool HLSLParser::AcceptUnaryOperator(bool pre, HLSLUnaryOp& unaryOp); bool HLSLParser::AcceptAssign(HLSLBinaryOp& binaryOp); bool HLSLParser::ParseBinaryExpression(int priority, HLSLExpression*& expression); bool HLSLParser::ParsePartialConstructor(HLSLExpression*& expression, HLSLBaseType type, const char* typeName); bool HLSLParser::ParseTerminalExpression(HLSLExpression*& expression, bool& needsEndParen); bool HLSLParser::ParseExpressionList(int endToken, bool allowEmptyEnd, HLSLExpression*& firstExpression, int& numExpressions); bool HLSLParser::ParseArgumentList(HLSLArgument*& firstArgument, int& numArguments, int& numOutputArguments); bool HLSLParser::ParseSamplerState(HLSLExpression*& expression); bool HLSLParser::ParseTechnique(HLSLStatement*& statement); bool HLSLParser::ParsePass(HLSLPass*& pass); bool HLSLParser::ParsePipeline(HLSLStatement*& statement); const EffectState* GetEffectState(const char* name, bool isSamplerState, bool isPipeline); static const EffectStateValue* GetStateValue(const char* name, const EffectState* state); bool HLSLParser::ParseStateName(bool isSamplerState, bool isPipelineState, const char*& name, const EffectState *& state); bool HLSLParser::ParseColorMask(int& mask); bool HLSLParser::ParseStateValue(const EffectState * state, HLSLStateAssignment* stateAssignment); bool HLSLParser::ParseStateAssignment(HLSLStateAssignment*& stateAssignment, bool isSamplerState, bool isPipelineState); bool HLSLParser::ParseAttributeBlock(HLSLAttribute*& attribute); bool HLSLParser::ParseStage(HLSLStatement*& statement); bool HLSLParser::Parse(HLSLTree* tree); bool HLSLParser::AcceptTypeModifier(int& flags); bool HLSLParser::AcceptInterpolationModifier(int& flags); bool HLSLParser::AcceptType(bool allowVoid, HLSLType& type/*, bool acceptFlags*/); bool HLSLParser::ExpectType(bool allowVoid, HLSLType& type); bool HLSLParser::AcceptDeclaration(bool allowUnsizedArray, HLSLType& type, const char*& name); bool HLSLParser::ExpectDeclaration(bool allowUnsizedArray, HLSLType& type, const char*& name); const HLSLStruct* HLSLParser::FindUserDefinedType(const char* name); bool HLSLParser::CheckForUnexpectedEndOfStream(int endToken); int HLSLParser::GetLineNumber(); const char* HLSLParser::GetFileName(); void HLSLParser::BeginScope(); void HLSLParser::EndScope(); const HLSLType* HLSLParser::FindVariable(const char* name, bool& global); const HLSLFunction* HLSLParser::FindFunction(const char* name); static bool AreTypesEqual(HLSLTree* tree, const HLSLType& lhs, const HLSLType& rhs); static bool AreArgumentListsEqual(HLSLTree* tree, HLSLArgument* lhs, HLSLArgument* rhs); const HLSLFunction* HLSLParser::FindFunction(const HLSLFunction* fun); void HLSLParser::DeclareVariable(const char* name, const HLSLType& type); bool HLSLParser::GetIsFunction(const char* name); const HLSLFunction* HLSLParser::MatchFunctionCall(const HLSLFunctionCall* functionCall, const char* name); bool HLSLParser::GetMemberType(const HLSLType& objectType, HLSLMemberAccess * memberAccess);

75d40b9f074d92553ac58afd3d68a19ee25b66eb6d2beaf15327b1a40e6fc832

meatich

Viy

src/include/Nvim/Neovim.cpp

nvim::Neovim::update

void nvim::Neovim::update(sf::Time dt) { bridgeData.updateMutex.lock(); if (mNeedResize) { resize(mNewRowSize, mNewColSize); mNeedResize = false; bridgeData.resizeMutex.unlock(); } if (mNeedRedraw) { mBackgroundRenderer.update(); mTextRenderer.update(); mPictureRenderer.update(); mBlinky.update(dt, true); scheduleRedraw(false); } else mBlinky.update(dt); if (bridgeData.switchToNavigatorFlag) { bridgeData.switchToNavigatorFlag = false; mSignals.switchToNavigator.status = true; } bridgeData.updateMutex.unlock(); }

nvim::Neovim::Neovim(const InitData &initData, Signals &signals); void nvim::Neovim::render(sf::RenderTarget &target, const sf::RenderStates &states); void nvim::Neovim::changeMode(nvim::Blinky::Mode mode); void nvim::Neovim::quit(); void nvim::Neovim::setTitle(const char *title); void nvim::Neovim::resize(int rows, int cols); void nvim::Neovim::scheduleRedraw(bool f); void nvim::Neovim::scheduleResize(int rows, int cols); void nvim::Neovim::handleEvent(const sf::Event &event); void nvim::Neovim::openPath(std::string path); void nvim::Neovim::input(std::string query); void nvim::Neovim::checkForResize(const sf::Event &event);

c5378d115d739d7415b8486716bdffb63a041bae2b17166b315f474799dc3973

plankton11

BodySlide-and-Outfit-Studio

src/program/BodySlideApp.cpp

BodySlideApp::InitLanguage

void BodySlideApp::InitLanguage() { if (Config["UseSystemLanguage"] != "true") return; if (locale) delete locale; language = wxLocale::GetSystemLanguage(); if (wxLocale::IsAvailable(language)) { locale = new wxLocale(language); locale->AddCatalogLookupPathPrefix("lang"); locale->AddCatalog("BodySlide"); if (!locale->IsOk()) { wxLogError("System language '%d' is wrong.", language); wxMessageBox(wxString::Format(_("System language '%d' is wrong."), language)); delete locale; locale = new wxLocale(wxLANGUAGE_ENGLISH); language = wxLANGUAGE_ENGLISH; } } else { wxLogError("The system language '%d' is not supported by your system. Try installing support for this language.", language); wxMessageBox(wxString::Format(_("The system language '%d' is not supported by your system. Try installing support for this language."), language)); locale = new wxLocale(wxLANGUAGE_ENGLISH); language = wxLANGUAGE_ENGLISH; } wxLogMessage("Using language '%s'.", wxLocale::GetLanguageName(language)); }

BodySlideApp::~BodySlideApp(); bool BodySlideApp::OnInit(); void BodySlideApp::OnInitCmdLine(wxCmdLineParser& parser); bool BodySlideApp::OnCmdLineParsed(wxCmdLineParser& parser); bool BodySlideApp::OnExceptionInMainLoop(); void BodySlideApp::OnUnhandledException(); void BodySlideApp::OnFatalException(); void BodySlideApp::InitArchives(); void BodySlideApp::GetArchiveFiles(vector<string>& outList); void BodySlideApp::LoadData(); int BodySlideApp::CreateSetSliders(const string& outfit); void BodySlideApp::RefreshOutfitList(); int BodySlideApp::LoadSliderSets(); void BodySlideApp::ActivateOutfit(const string& outfitName); void BodySlideApp::ActivatePreset(const string &presetName, const bool updatePreview); void BodySlideApp::RefreshSliders(); void BodySlideApp::PopulatePresetList(const string& select); void BodySlideApp::PopulateOutfitList(const string& select); void BodySlideApp::DisplayActiveSet(); void BodySlideApp::LaunchOutfitStudio(); void BodySlideApp::ApplySliders(const string& targetShape, vector<Slider>& sliderSet, vector<Vector3>& verts, vector<ushort>& ZapIdx, vector<Vector2>* uvs); int BodySlideApp::WriteMorphTRI(const string& triPath, SliderSet& sliderSet, NifFile& nif, unordered_map<string, vector<ushort>>& zapIndices); void BodySlideApp::CopySliderValues(bool toHigh); void BodySlideApp::ShowPreview(); void BodySlideApp::InitPreview(); void BodySlideApp::UpdatePreview(); void BodySlideApp::CleanupPreview(); void BodySlideApp::RebuildPreviewMeshes(); bool BodySlideApp::SetDefaultConfig(); bool BodySlideApp::ShowSetup(); wxString BodySlideApp::GetGameDataPath(TargetGame targ); void BodySlideApp::LoadAllCategories(); void BodySlideApp::SetPresetGroups(const string& setName); void BodySlideApp::LoadAllGroups(); void BodySlideApp::GetAllGroupNames(vector<string>& outGroups); int BodySlideApp::SaveGroupList(const string& fileName, const string& groupName); void BodySlideApp::ApplyOutfitFilter(); int BodySlideApp::GetOutfits(vector<string>& outList); int BodySlideApp::GetFilteredOutfits(vector<string>& outList); void BodySlideApp::LoadPresets(const string& sliderSet); int BodySlideApp::BuildBodies(bool localPath, bool clean, bool tri); void BodySlideApp::GroupBuild(const string& group); float BodySlideApp::GetSliderValue(const wxString& sliderName, bool isLo); bool BodySlideApp::IsUVSlider(const wxString& sliderName); vector<string> BodySlideApp::GetSliderZapToggles(const wxString& sliderName); void BodySlideApp::SetSliderValue(const wxString& sliderName, bool isLo, float val); void BodySlideApp::SetSliderChanged(const wxString& sliderName, bool isLo); int BodySlideApp::UpdateSliderPositions(const string& presetName); int BodySlideApp::SaveSliderPositions(const string& outputFile, const string& presetName, vector<string>& groups); BodySlideFrame::BodySlideFrame(BodySlideApp* app, const wxSize &size); void BodySlideFrame::OnLinkClicked(wxHtmlLinkEvent& link); void BodySlideFrame::OnEnterClose(wxKeyEvent& event); void BodySlideFrame::OnEnterSliderWindow(wxMouseEvent& event); void BodySlideFrame::ShowLowColumn(bool show); void BodySlideFrame::AddCategorySliderUI(const wxString& name, bool show, bool oneSize); void BodySlideFrame::AddSliderGUI(const wxString& name, const wxString& displayName, bool isZap, bool oneSize); void BodySlideFrame::ClearPresetList(); void BodySlideFrame::ClearOutfitList(); void BodySlideFrame::ClearSliderGUI(); void BodySlideFrame::PopulateOutfitList(const wxArrayString& items, const wxString& selectItem); void BodySlideFrame::PopulatePresetList(const wxArrayString& items, const wxString& selectItem); void BodySlideFrame::SetSliderPosition(const wxString &name, float newValue, short HiLo); void BodySlideFrame::OnExit(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnClose(wxCloseEvent& WXUNUSED(event); void BodySlideFrame::OnActivateFrame(wxActivateEvent& event); void BodySlideFrame::OnIconizeFrame(wxIconizeEvent& event); void BodySlideFrame::PostIconizeFrame(); void BodySlideFrame::OnSliderChange(wxScrollEvent& event); void BodySlideFrame::OnSliderReadoutChange(wxCommandEvent& event); void BodySlideFrame::OnSearchChange(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnOutfitSearchChange(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnCategoryCheckChanged(wxCommandEvent& event); void BodySlideFrame::OnZapCheckChanged(wxCommandEvent& event); void BodySlideFrame::OnEraseBackground(wxEraseEvent &WXUNUSED(event); void BodySlideFrame::OnDelayLoad(wxTimerEvent& WXUNUSED(event); void BodySlideFrame::OnChooseGroups(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnSaveGroups(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnRefreshGroups(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnRefreshOutfits(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnChooseOutfit(wxCommandEvent& event); void BodySlideFrame::OnChoosePreset(wxCommandEvent& event); void BodySlideFrame::OnSavePreset(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnSavePresetAs(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnGroupManager(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnHighToLow(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnLowToHigh(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnPreview(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnBuildBodies(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnBatchBuild(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnBatchBuildContext(wxMouseEvent& WXUNUSED(event); void BodySlideFrame::OnBatchBuildSelect(wxCommandEvent& event); void BodySlideFrame::OnOutfitStudio(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnChooseTargetGame(wxCommandEvent& event); void BodySlideFrame::SettingsFillDataFiles(wxCheckListBox* dataFileList, wxString& dataDir, int targetGame); void BodySlideFrame::OnSettings(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnAbout(wxCommandEvent& WXUNUSED(event); void BodySlideFrame::OnMoveWindow(wxMoveEvent& event); void BodySlideFrame::OnSetSize(wxSizeEvent& event);

91ec57979559b42e9ab868bd64c1fc053a3da40908325b056c26bf40284a5d79

kronihias

mcfx

JUCE/modules/juce_audio_devices/native/juce_android_Oboe.cpp

checkStreamSetup

void checkStreamSetup (OboeStream* stream, int deviceId, int numChannels, int sampleRate, int bufferSize, oboe::AudioFormat format) { if (auto* nativeStream = stream != nullptr ? stream->getNativeStream() : nullptr) { ignoreUnused (deviceId, numChannels, sampleRate, bufferSize); ignoreUnused (streamFormat, bitDepth); jassert (numChannels == nativeStream->getChannelCount()); jassert (sampleRate == 0 || sampleRate == nativeStream->getSampleRate()); jassert (format == nativeStream->getFormat()); } }

static void convertFromOboe (const int16* srcInterleaved, AudioBuffer<float>& audioBuffer, int numSamples); static void convertToOboe (const AudioBuffer<float>& audioBuffer, int16* dstInterleaved, int numSamples); static void referAudioBufferDirectlyToOboeIfPossible (float* nativeBuffer, AudioBuffer<float>& audioBuffer, int numSamples); static void convertFromOboe (const float* srcInterleaved, AudioBuffer<float>& audioBuffer, int numSamples); static void convertToOboe (const AudioBuffer<float>& audioBuffer, float* dstInterleaved, int numSamples); static String getOboeString (const Type& value); ~OboeAudioIODevice(); Array<double> getAvailableSampleRates(); Array<int> getAvailableBufferSizes(); String open (const BigInteger& inputChannels, const BigInteger& outputChannels, double requestedSampleRate, int bufferSize); int getDefaultBufferSize(); double getCurrentSampleRate(); void start (AudioIODeviceCallback* newCallback); void stop(); bool setAudioPreprocessingEnabled (bool); StringArray getChannelNames (bool forInput); Array<int> getAvailableSampleRates (bool forInput); static Array<int> getDefaultSampleRates(); void setCallback (AudioIODeviceCallback* callbackToUse); void process (const float** inputChannelData, int numInputChannels, float** outputChannelData, int numOutputChannels, int32_t numFrames); ~OboeStream(); bool openedOk(); void start(); oboe::AudioStream* getNativeStream(); int getXRunCount(); void close(); bool openedOk(); int getXRunCount(); int getBufferCapacityInFrames (bool forInput); void start(); void stop(); bool isLatencyDetectionSupported (OboeStream* stream); oboe::DataCallbackResult onAudioReady (oboe::AudioStream* stream, void* audioData, int32_t numFrames); void printStreamDebugInfo (oboe::AudioStream* stream); int getLatencyFor (OboeStream& stream); int64_t getCurrentTimeNanos(); void onErrorBeforeClose (oboe::AudioStream* stream, oboe::Result error); void onErrorAfterClose (oboe::AudioStream* stream, oboe::Result error); static double getNativeSampleRate(); static int getNativeBufferSize(); static bool isProAudioDevice(); static int getDefaultFramesPerBurst(); OboeAudioIODeviceType(); StringArray getDeviceNames (bool wantInputNames); int getDefaultDeviceIndex (bool forInput); int getIndexOfDevice (AudioIODevice* device, bool asInput); AudioIODevice* createDevice (const String& outputDeviceName, const String& inputDeviceName); static bool isOboeAvailable(); void checkAvailableDevices(); bool supportsDevicesInfo(); void addDevice (const LocalRef<jobject>& device, JNIEnv* env); static const char* deviceTypeToString (int type); static Array<int> jintArrayToJuceArray (const LocalRef<jintArray>& jArray); DeviceInfo getDeviceInfoForName (const String& name, bool isInput); AudioIODeviceType* AudioIODeviceType::createAudioIODeviceType_Oboe(); OboeRealtimeThread(); bool isOk(); pthread_t startThread (void*(*entry); oboe::DataCallbackResult onAudioReady (oboe::AudioStream*, void*, int32_t); void onErrorBeforeClose (oboe::AudioStream*, oboe::Result error); void onErrorAfterClose (oboe::AudioStream*, oboe::Result error); pthread_t juce_createRealtimeAudioThread (void* (*entry);

564627a6a3e5df2ce8180bee238a85b48ef733979872e72fdbecccadf8079885

JanMarvin

rstudio

src/cpp/core/BoostErrors.cpp

ec_from_exception

boost::system::error_code ec_from_exception( const boost::thread_resource_error& e) { return error_code(errc::thread_resource_error, thread_category()); }

const error_category& interprocess_category(); const char* interprocess_error_category::name(); std::string interprocess_error_category::message(int ev); boost::system::error_code ec_from_exception(const interprocess_exception& e); const error_category& thread_category(); const char* thread_error_category::name(); std::string thread_error_category::message(int ev);

4ee0e5a5e29ea0ca1bf6b9c29467197647c3252645c81dc73866c779d4890ec2

thetoconet

Toco

toco_ui/toco_qml_plugin/tsecurityproxy.cpp

TSecurityProxy::status

TSecurityProxy::Status TSecurityProxy::status() const { return m_status; }

TSecurityProxy::TSecurityProxy(QQuickItem *parent); TSecurityProxy::~TSecurityProxy(); QString TSecurityProxy::statusLabel(); QString TSecurityProxy::alarmOn(); void TSecurityProxy::arm(int armDelayTime, int entryDelay); void TSecurityProxy::disarm(const QString &code); void TSecurityProxy::emergency(const QString &nameId); void TSecurityProxy::emergencyOff(const QString &code); QVariantMap TSecurityProxy::motionData(int windowId); void TSecurityProxy::statusUpdate(); void TSecurityProxy::methodSlot(QStringList call); void TSecurityProxy::notificationSlot(QStringList notify); void TSecurityProxy::setStatus(TSecurityProxy::Status status); void TSecurityProxy::setAlarmOn(const QString &nameId);

83d2ac9e49b1c4a0ffc6a3f1f9fe4ce522a4b2bc3ac479fbf39ce24753f46e65

rochus-keller

NAF

Qtl2/QtlAbstractItemView.cpp

setItemDelegateForRow

static int setItemDelegateForRow(lua_State * L) { QAbstractItemView* obj = QtObject<QAbstractItemView>::check( L, 1 ); obj->setItemDelegateForRow( Util::toInt( L, 2 ), QtObject<QAbstractItemDelegate>::check( L, 3 ) ); return 0; }

static int MI_init(lua_State * L); static int MI_child(lua_State * L); static int MI_column(lua_State * L); static int MI_data(lua_State * L); static int MI_flags(lua_State * L); static int MI_internalId(lua_State * L); static int MI_internalPointer(lua_State * L); static int MI_isValid(lua_State * L); static int MI_model(lua_State * L); static int MI_parent(lua_State * L); static int MI_row(lua_State * L); static int MI_sibling(lua_State * L); static int closePersistentEditor(lua_State * L); static int currentIndex(lua_State * L); static int indexAt(lua_State * L); static int indexWidget(lua_State * L); static int itemDelegate(lua_State * L); static int itemDelegateForColumn(lua_State * L); static int itemDelegateForRow(lua_State * L); static int keyboardSearch(lua_State * L); static int model(lua_State * L); static int openPersistentEditor(lua_State * L); static int rootIndex(lua_State * L); static int selectionModel(lua_State * L); static int setIndexWidget(lua_State * L); static int setItemDelegate(lua_State * L); static int setItemDelegateForColumn(lua_State * L); static int sizeHintForIndex(lua_State * L); static int sizeHintForRow(lua_State * L); void AbstractItemView::install(lua_State * L);

9e48d97d6d31b33f2243f0e20999a4cba6b2798ecba1954d06c61eb2fdd65852

rherardi

xml-xalan-c-src_1_10_0

src/xalanc/XercesParserLiaison/Deprecated/XercesDocumentBridge.cpp

XercesElementBridge* XercesDocumentBridge::createBridgeNode

XercesElementBridge* XercesDocumentBridge::createBridgeNode( const DOM_ElementType& theXercesNode, IndexType theIndex, bool mapNode) const { XercesBridgeNavigator& theNavigator = pushNavigator(mapNode); theNavigator.setIndex(theIndex); #if defined(XALAN_NO_MUTABLE) XercesDocumentBridge* const This = (XercesDocumentBridge*)this; #else const XercesDocumentBridge* const This = this; #endif XercesElementBridge* const theBridge = This->m_elementAllocator.create(theXercesNode, theNavigator); if (m_doctype != 0 || mapNode == true) { This->m_nodeMap.addAssociation(theXercesNode, theBridge); } return theBridge; }

XercesDocumentBridge::~XercesDocumentBridge(); XercesDocumentBridge::BuildBridgeTreeWalker::~BuildBridgeTreeWalker();

1719d1e0d85ca418485f2eda4bebe278e4a3d0e12a017eeb06618fe94d74f71b

axeisghost

DART6motionBlur

unittests/unit/test_Signal.cpp

TEST

TEST(Signal, FrameSignals) { Isometry3d tf1(Isometry3d::Identity()); tf1.translate(Vector3d(0.1,-0.1,0)); Isometry3d tf2(Isometry3d::Identity()); tf2.translate(Vector3d(0,0.1,0)); tf2.rotate(AngleAxisd(45.0*M_PI/180.0, Vector3d(1,0,0))); Isometry3d tf3(Isometry3d::Identity()); tf3.translate(Vector3d(0,0,0.1)); tf3.rotate(AngleAxisd(60*M_PI/180.0, Vector3d(0,1,0))); SimpleFrame F1(Frame::World(), "F1", tf1); SimpleFrame F2(&F1, "F2", tf2); SimpleFrame F3(&F2, "F3", tf3); Connection cf1 = F1.onFrameChanged.connect(frameChangeCallback); Connection cf2 = F2.onFrameChanged.connect(frameChangeCallback); ScopedConnection cf3(F3.onFrameChanged.connect(frameChangeCallback)); Connection cv1 = F1.onNameChanged.connect(nameChangedCallback); Connection cv2 = F2.onNameChanged.connect(nameChangedCallback); ScopedConnection cv3(F3.onNameChanged.connect(nameChangedCallback)); F1.setName("new " + F1.getName()); F2.setName("new " + F2.getName()); F3.setName("new " + F3.getName()); F3.setParentFrame(&F1); }

TEST(Signal, Basic); TEST(Signal, NonStaticMemberFunction); TEST(Signal, ScopedConnection); TEST(Signal, ConnectionLifeTime); static T process(InputIterator first, InputIterator last); static T process(InputIterator first, InputIterator last); TEST(Signal, ReturnValues); int main(int argc, char* argv[]);

7e2412d1f5b71940004d8874f5dc88cd13ae3b4839cee5cafde95b5182525d34

folbo

MuseScore

libmscore/stem.cpp

Stem::spatiumChanged

void Stem::spatiumChanged(qreal oldValue, qreal newValue) { _userLen = (_userLen / oldValue) * newValue; layout(); }

Stem::Stem(Score* s); bool Stem::up(); qreal Stem::stemLen(); void Stem::layout(); void Stem::setLen(qreal v); void Stem::draw(QPainter* painter); void Stem::write(XmlWriter& xml); void Stem::read(XmlReader& e); void Stem::updateGrips(EditData& ed); void Stem::startEdit(EditData& ed); void Stem::editDrag(EditData& ed); void Stem::reset(); bool Stem::acceptDrop(EditData& data); Element* Stem::drop(EditData& data); QVariant Stem::getProperty(P_ID propertyId); bool Stem::setProperty(P_ID propertyId, const QVariant& v); QPointF Stem::hookPos();

8b28178b7bfd83c69cc3bc6fc0e25121d4c0dda6cfb373c8d05ab1d3f6a9666b

mbert

mulberry-lib-cicalendar

Source/CICalendarComponentRecur.cpp

CICalendarComponentRecur::IsRecurring

bool CICalendarComponentRecur::IsRecurring() const { return (mRecurrences != NULL) && mRecurrences->HasRecurrence(); }

bool CICalendarComponentRecur::sort_by_dtstart_allday(CICalendarComponentRecur* e1, CICalendarComponentRecur* e2); bool CICalendarComponentRecur::sort_by_dtstart(CICalendarComponentRecur* e1, CICalendarComponentRecur* e2); CICalendarComponentRecur::CICalendarComponentRecur(const CICalendarRef& calendar); CICalendarComponentRecur::CICalendarComponentRecur(const CICalendarComponentRecur& copy); void CICalendarComponentRecur::_copy_CICalendarComponentRecur(const CICalendarComponentRecur& copy); void CICalendarComponentRecur::_tidy_CICalendarComponentRecur(); void CICalendarComponentRecur::Finalise(); void CICalendarComponentRecur::FixStartEnd(); cdstring CICalendarComponentRecur::MapKey(const cdstring& uid); cdstring CICalendarComponentRecur::MapKey(const cdstring& uid, const cdstring& rid); void CICalendarComponentRecur::SetUID(const cdstring& uid); cdstring CICalendarComponentRecur::GetMasterKey(); void CICalendarComponentRecur::InitDTSTAMP(); cdstring CICalendarComponentRecur::GetDescription(); cdstring CICalendarComponentRecur::GetLocation(); bool CICalendarComponentRecur::GetTransparent(); void CICalendarComponentRecur::SetMaster(CICalendarComponentRecur* master); void CICalendarComponentRecur::InitFromMaster(); void CICalendarComponentRecur::ExpandPeriod(const CICalendarPeriod& period, CICalendarExpandedComponents& list); bool CICalendarComponentRecur::WithinPeriod(const CICalendarPeriod& period); CICalendarComponentExpandedShared CICalendarComponentRecur::CreateExpanded(CICalendarComponentRecur* master, const CICalendarDateTime& recurid); void CICalendarComponentRecur::ChangedRecurrence(); void CICalendarComponentRecur::EditSummary(const cdstring& summary); void CICalendarComponentRecur::EditDetails(const cdstring& description, const cdstring& location); void CICalendarComponentRecur::EditTransparent(bool transparent); void CICalendarComponentRecur::EditTiming(); void CICalendarComponentRecur::EditTiming(const CICalendarDateTime& due); void CICalendarComponentRecur::EditTiming(const CICalendarDateTime& start, const CICalendarDateTime& end); void CICalendarComponentRecur::EditTiming(const CICalendarDateTime& start, const CICalendarDuration& duration); void CICalendarComponentRecur::EditRecurrenceSet(const CICalendarRecurrenceSet& recurs); void CICalendarComponentRecur::ExcludeRecurrence(const CICalendarDateTime& start); void CICalendarComponentRecur::ExcludeFutureRecurrence(const CICalendarDateTime& start); bool CICalendarComponentRecur::LoadValue(const char* value_name, int32_t& value, CICalendarValue::EICalValueType type); bool CICalendarComponentRecur::LoadValue(const char* value_name, cdstring& value); bool CICalendarComponentRecur::LoadValue(const char* value_name, CICalendarDateTime& value); bool CICalendarComponentRecur::LoadValue(const char* value_name, CICalendarDuration& value); bool CICalendarComponentRecur::LoadValue(const char* value_name, CICalendarPeriod& value); bool CICalendarComponentRecur::LoadValueRRULE(const char* value_name, CICalendarRecurrenceSet& value, bool add); bool CICalendarComponentRecur::LoadValueRDATE(const char* value_name, CICalendarRecurrenceSet& value, bool add);

605e748f26faf041d5f6e0a4bcd4c4ff2a1471174e32ec0ca4877d0a395474b5

kyungtaekLIM

PSI-BLASTexB

src/ncbi-blast-2.5.0+/c++/src/algo/blast/unit_tests/api/querydata_unit_test.cpp

CSequenceDataTester::CSequenceDataTester

CSequenceDataTester::CSequenceDataTester(CRef<IQueryFactory> query_factory, TGi gi) : m_QueryFactory(query_factory), m_Gis(1, gi) { x_Init(); }

static void s_ObjMgrFree_QueryFactory_LocalDataFromBioseq(TGi kGi); static void s_ObjMgrFree_QueryFactory_LocalDataFromBioseq_set(const vector<TGi>& gis); static void s_ObjMgr_QueryFactory_LocalDataFromTSeqLocVector(const vector<TGi>& gis); static void s_ObjMgr_QueryFactory_LocalDataFromBlastQueryVector(const vector<TGi>& gis); static void create_EmptyTSeqLocVector(); static void create_EmptyBlastQueryVector(); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_LocalData_GetSumOfSequenceLengths); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_LocalDataFromTSeqLocVector_Protein); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_LocalDataFromTSeqLocVector_Nucleotide); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_LocalDataFromBlastQueryVector_Protein); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_LocalDataFromBlastQueryVector_Nucleotide); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_RemoteData_SingleBioseqFromTSeqLocVector); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_RemoteData_SingleBioseqFromBlastQueryVector); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_EmptyTSeqLocVector); BOOST_AUTO_TEST_CASE(ObjMgr_QueryFactory_EmptyBlastQueryVector); BOOST_AUTO_TEST_CASE(ObjMgrFree_QueryFactory_LocalDataFromBioseq_Protein); BOOST_AUTO_TEST_CASE(ObjMgrFree_QueryFactory_LocalDataFromBioseq_Nucleotide); BOOST_AUTO_TEST_CASE(ObjMgrFree_QueryFactory_LocalDataFromBioseq_set_Protein); BOOST_AUTO_TEST_CASE(ObjMgrFree_QueryFactory_LocalDataFromBioseq_set_Nucleotide);

d9d4031b3529a12cc04f1976f1de7addda2b9060f5a3bbb9a277e07249a2a149

Discover-

Trinity-Zero

src/server/game/Spells/SpellScript.cpp

SpellScript::GetHitPlayer

Player* SpellScript::GetHitPlayer() { if (!IsInTargetHook()) { sLog->outError("TSCR: Script: `%s` Spell: `%u`: function SpellScript::GetHitPlayer was called, but function has no effect in current hook!", m_scriptName->c_str(), m_scriptSpellId); return NULL; } if (m_spell->unitTarget) return m_spell->unitTarget->ToPlayer(); else return NULL; }

bool _SpellScript::_Validate(SpellInfo const* entry); void _SpellScript::_Register(); void _SpellScript::_Unload(); void _SpellScript::_Init(std::string const* scriptname, uint32 spellId); std::string const* _SpellScript::_GetScriptName(); _SpellScript::EffectHook::EffectHook(uint8 _effIndex); uint8 _SpellScript::EffectHook::GetAffectedEffectsMask(SpellInfo const* spellEntry); bool _SpellScript::EffectHook::IsEffectAffected(SpellInfo const* spellEntry, uint8 effIndex); std::string _SpellScript::EffectHook::EffIndexToString(); bool _SpellScript::EffectNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex); std::string _SpellScript::EffectNameCheck::ToString(); bool _SpellScript::EffectAuraNameCheck::Check(SpellInfo const* spellEntry, uint8 effIndex); std::string _SpellScript::EffectAuraNameCheck::ToString(); SpellScript::CastHandler::CastHandler(SpellCastFnType _pCastHandlerScript); void SpellScript::CastHandler::Call(SpellScript* spellScript); SpellScript::CheckCastHandler::CheckCastHandler(SpellCheckCastFnType checkCastHandlerScript); SpellCastResult SpellScript::CheckCastHandler::Call(SpellScript* spellScript); SpellScript::EffectHandler::EffectHandler(SpellEffectFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); std::string SpellScript::EffectHandler::ToString(); bool SpellScript::EffectHandler::CheckEffect(SpellInfo const* spellEntry, uint8 effIndex); void SpellScript::EffectHandler::Call(SpellScript* spellScript, SpellEffIndex effIndex); SpellScript::HitHandler::HitHandler(SpellHitFnType _pHitHandlerScript); void SpellScript::HitHandler::Call(SpellScript* spellScript); SpellScript::UnitTargetHandler::UnitTargetHandler(SpellUnitTargetFnType _pUnitTargetHandlerScript, uint8 _effIndex, uint16 _targetType); std::string SpellScript::UnitTargetHandler::ToString(); bool SpellScript::UnitTargetHandler::CheckEffect(SpellInfo const* spellEntry, uint8 effIndex); void SpellScript::UnitTargetHandler::Call(SpellScript* spellScript, std::list<Unit*>& unitTargets); bool SpellScript::_Validate(SpellInfo const* entry); bool SpellScript::_Load(Spell* spell); void SpellScript::_InitHit(); void SpellScript::_PrepareScriptCall(SpellScriptHookType hookType); void SpellScript::_FinishScriptCall(); bool SpellScript::IsInCheckCastHook(); bool SpellScript::IsInTargetHook(); bool SpellScript::IsInHitPhase(); bool SpellScript::IsInEffectHook(); Unit* SpellScript::GetCaster(); Unit* SpellScript::GetOriginalCaster(); SpellInfo const* SpellScript::GetSpellInfo(); WorldLocation const* SpellScript::GetExplTargetDest(); void SpellScript::SetExplTargetDest(WorldLocation& loc); WorldObject* SpellScript::GetExplTargetWorldObject(); Unit* SpellScript::GetExplTargetUnit(); GameObject* SpellScript::GetExplTargetGObj(); Item* SpellScript::GetExplTargetItem(); Unit* SpellScript::GetHitUnit(); Creature* SpellScript::GetHitCreature(); Item* SpellScript::GetHitItem(); GameObject* SpellScript::GetHitGObj(); WorldLocation* SpellScript::GetHitDest(); int32 SpellScript::GetHitDamage(); void SpellScript::SetHitDamage(int32 damage); int32 SpellScript::GetHitHeal(); void SpellScript::SetHitHeal(int32 heal); Aura* SpellScript::GetHitAura(); void SpellScript::PreventHitAura(); void SpellScript::PreventHitEffect(SpellEffIndex effIndex); void SpellScript::PreventHitDefaultEffect(SpellEffIndex effIndex); int32 SpellScript::GetEffectValue(); Item* SpellScript::GetCastItem(); void SpellScript::CreateItem(uint32 effIndex, uint32 itemId); SpellInfo const* SpellScript::GetTriggeringSpell(); void SpellScript::FinishCast(SpellCastResult result); void SpellScript::SetCustomCastResultMessage(SpellCustomErrors result); SpellValue const* SpellScript::GetSpellValue(); bool AuraScript::_Validate(SpellInfo const* entry); AuraScript::CheckAreaTargetHandler::CheckAreaTargetHandler(AuraCheckAreaTargetFnType _pHandlerScript); bool AuraScript::CheckAreaTargetHandler::Call(AuraScript* auraScript, Unit* _target); AuraScript::AuraDispelHandler::AuraDispelHandler(AuraDispelFnType _pHandlerScript); void AuraScript::AuraDispelHandler::Call(AuraScript* auraScript, DispelInfo* _dispelInfo); AuraScript::EffectBase::EffectBase(uint8 _effIndex, uint16 _effName); bool AuraScript::EffectBase::CheckEffect(SpellInfo const* spellEntry, uint8 effIndex); std::string AuraScript::EffectBase::ToString(); AuraScript::EffectPeriodicHandler::EffectPeriodicHandler(AuraEffectPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); void AuraScript::EffectPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff); AuraScript::EffectUpdatePeriodicHandler::EffectUpdatePeriodicHandler(AuraEffectUpdatePeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); void AuraScript::EffectUpdatePeriodicHandler::Call(AuraScript* auraScript, AuraEffect* aurEff); AuraScript::EffectCalcAmountHandler::EffectCalcAmountHandler(AuraEffectCalcAmountFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); void AuraScript::EffectCalcAmountHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, int32& amount, bool& canBeRecalculated); AuraScript::EffectCalcPeriodicHandler::EffectCalcPeriodicHandler(AuraEffectCalcPeriodicFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); void AuraScript::EffectCalcPeriodicHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, bool& isPeriodic, int32& periodicTimer); AuraScript::EffectCalcSpellModHandler::EffectCalcSpellModHandler(AuraEffectCalcSpellModFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName); void AuraScript::EffectCalcSpellModHandler::Call(AuraScript* auraScript, AuraEffect const* aurEff, SpellModifier*& spellMod); AuraScript::EffectApplyHandler::EffectApplyHandler(AuraEffectApplicationModeFnType _pEffectHandlerScript, uint8 _effIndex, uint16 _effName, AuraEffectHandleModes _mode); void AuraScript::EffectApplyHandler::Call(AuraScript* auraScript, AuraEffect const* _aurEff, AuraEffectHandleModes _mode); AuraScript::EffectAbsorbHandler::EffectAbsorbHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex); void AuraScript::EffectAbsorbHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount); AuraScript::EffectManaShieldHandler::EffectManaShieldHandler(AuraEffectAbsorbFnType _pEffectHandlerScript, uint8 _effIndex); void AuraScript::EffectManaShieldHandler::Call(AuraScript* auraScript, AuraEffect* aurEff, DamageInfo& dmgInfo, uint32& absorbAmount); bool AuraScript::_Load(Aura* aura); void AuraScript::_PrepareScriptCall(AuraScriptHookType hookType, AuraApplication const* aurApp); void AuraScript::_FinishScriptCall(); bool AuraScript::_IsDefaultActionPrevented(); void AuraScript::PreventDefaultAction(); SpellInfo const* AuraScript::GetSpellInfo(); uint32 AuraScript::GetId(); uint64 AuraScript::GetCasterGUID(); Unit* AuraScript::GetCaster(); WorldObject* AuraScript::GetOwner(); Unit* AuraScript::GetUnitOwner(); DynamicObject* AuraScript::GetDynobjOwner(); void AuraScript::Remove(uint32 removeMode); Aura* AuraScript::GetAura(); AuraObjectType AuraScript::GetType(); int32 AuraScript::GetDuration(); void AuraScript::SetDuration(int32 duration, bool withMods); void AuraScript::RefreshDuration(); time_t AuraScript::GetApplyTime(); int32 AuraScript::GetMaxDuration(); void AuraScript::SetMaxDuration(int32 duration); int32 AuraScript::CalcMaxDuration(); bool AuraScript::IsExpired(); bool AuraScript::IsPermanent(); uint8 AuraScript::GetCharges(); void AuraScript::SetCharges(uint8 charges); uint8 AuraScript::CalcMaxCharges(); bool AuraScript::ModCharges(int8 num, AuraRemoveMode removeMode /*= AURA_REMOVE_BY_DEFAULT*/); bool AuraScript::DropCharge(AuraRemoveMode removeMode); uint8 AuraScript::GetStackAmount(); void AuraScript::SetStackAmount(uint8 num); bool AuraScript::ModStackAmount(int32 num, AuraRemoveMode removeMode); bool AuraScript::IsPassive(); bool AuraScript::IsDeathPersistent(); bool AuraScript::HasEffect(uint8 effIndex); AuraEffect* AuraScript::GetEffect(uint8 effIndex); bool AuraScript::HasEffectType(AuraType type); Unit* AuraScript::GetTarget(); AuraApplication const* AuraScript::GetTargetApplication();

6820449cdf011b2614144abf9173a224cad3b2f02ccb0ee3b3288f0d4c5e19da

dooglio

turnwatcher

src/molib/src/image_ppm.cpp

GetValue

long GetValue(moIStream& file, long max_value) { long value; value = ReadValue(file); if(value <= 0) { value = 0; } else if(value > 255) { value = 255; } else if(max_value != 255) { value = value * 255 / max_value; } return value; }

int GetC(moIStream& file); long GetNextC(moIStream& file); long ReadValue(moIStream& file); bool Load(moIStream& file, moImage& im); bool Save(moOStream& file, const moImage& im); virtual const char *MimeType(void); virtual long MatchPriority(void); virtual long MatchType(const void *buffer, unsigned long size);

ecee01548ead791d92bd6fddcd8de0153f1aa1e1ed864086d2b6a6a0c78c12bc

tomix86

hpcpm

backend/src/utility/Functional.cpp

toString

std::string toString( bool b ) { return b ? "true" : "false"; }

bool toBool( std::string str ); int tryParseInt( std::string value, int minLegalValue, int maxLegalValue ); std::vector<std::string> tokenizeString( std::string input, char separator );

8b58a503c2d377a3e32581561d71fb479ecbc12c3cd665dff2ed8c1e12b65b78

JanMarvin

rstudio

src/cpp/r/session/RSessionState.cpp

setEnvVar

void setEnvVar(const std::string& name, const std::string& value) { if (isRLocationVariable(name) && !core::system::getenv(name).empty()) return; if (name == "RSTUDIO_SESSION_ROUTE" && !core::system::getenv(name).empty()) return; if (name == "RSTUDIO_PROGRAM_MODE" && !core::system::getenv(name).empty()) return; if (name == "RSTUDIO_VERSION" && !core::system::getenv(name).empty()) return; if (name == "RS_SERVER_RPC_SOCKET_PATH" && !core::system::getenv(name).empty()) return; if (name == "RS_SERVER_TMP_DIR" && !core::system::getenv(name).empty()) return; if (name == "RS_SERVER_LOCAL_SOCKET_PATH" && !core::system::getenv(name).empty()) return; if (name == "RS_MONITOR_SOCKET_PATH" && !core::system::getenv(name).empty()) return; if (name == "RS_SESSION_TMP_DIR" && !core::system::getenv(name).empty()) return; if (name == "RSTUDIO_STANDALONE_PORT" && !core::system::getenv(name).empty()) return; if (name == "RSTUDIO_SESSION_RSA_PRIVATE_KEY" && !core::system::getenv(name).empty()) return; core::system::setenv(name, value); }

Error saveLibPaths(const FilePath& libPathsFile); Error restoreLibPaths(const FilePath& libPathsFile); bool isRLocationVariable(const std::string& name); Error saveRVersion(const FilePath& filePath); Error saveEnvironmentVars(const FilePath& envFile, const std::string& envVarBlacklist); Error restoreEnvironmentVars(const FilePath& envFile); ErrorRecorder(std::string* pMessages); void operator(); void saveDevMode(Settings* pSettings); bool rProfileOnRestore(const core::FilePath& statePath); bool packratModeEnabled(const core::FilePath& statePath); Error deferredRestore(const FilePath& statePath, bool serverMode); bool validateRestoredRVersion(const FilePath& filePath); bool destroy(const FilePath& statePath); SessionStateInfo getSessionStateInfo();

99de49e55bd9f99ba0b49f160a9a614944de589ed910bd94c111995ac835123c

Simran-B

arangodb

arangod/GeneralServer/HttpCommTask.cpp

HttpCommTask<T>::on_header_complete

int HttpCommTask<T>::on_header_complete(llhttp_t* p) { HttpCommTask<T>* me = static_cast<HttpCommTask<T>*>(p->data); if (!me->_lastHeaderField.empty()) { me->_request->setHeaderV2(std::move(me->_lastHeaderField), std::move(me->_lastHeaderValue)); } if ((p->http_major != 1 || p->http_minor != 0) && (p->http_major != 1 || p->http_minor != 1)) { me->sendSimpleResponse(rest::ResponseCode::HTTP_VERSION_NOT_SUPPORTED, rest::ContentType::UNSET, 1, VPackBuffer<uint8_t>()); return HPE_OK; } if (p->content_length > GeneralCommTask<T>::MaximalBodySize) { me->sendSimpleResponse(rest::ResponseCode::REQUEST_ENTITY_TOO_LARGE, rest::ContentType::UNSET, 1, VPackBuffer<uint8_t>()); return HPE_OK; } me->_shouldKeepAlive = llhttp_should_keep_alive(p); bool found; std::string const& expect = me->_request->header(StaticStrings::Expect, found); if (found && StringUtils::trim(expect) == "100-continue") { LOG_TOPIC("2b604", TRACE, arangodb::Logger::REQUESTS) << "received a 100-continue request"; char const* response = "HTTP/1.1 100 Continue\r\n\r\n"; auto buff = asio_ns::buffer(response, strlen(response)); asio_ns::async_write(me->_protocol->socket, buff, [self = me->shared_from_this()](asio_ns::error_code const& ec, std::size_t) { if (ec) { static_cast<HttpCommTask<T>*>(self.get())->close(ec); } }); return HPE_OK; } if (me->_request->requestType() == RequestType::HEAD) { return 1; } return HPE_OK; }

rest::RequestType llhttpToRequestType(llhttp_t* p); int HttpCommTask<T>::on_message_began(llhttp_t* p); int HttpCommTask<T>::on_url(llhttp_t* p, const char* at, size_t len); int HttpCommTask<T>::on_status(llhttp_t* p, const char* at, size_t len); int HttpCommTask<T>::on_header_field(llhttp_t* p, const char* at, size_t len); int HttpCommTask<T>::on_header_value(llhttp_t* p, const char* at, size_t len); int HttpCommTask<T>::on_body(llhttp_t* p, const char* at, size_t len); int HttpCommTask<T>::on_message_complete(llhttp_t* p); HttpCommTask<T>::HttpCommTask(GeneralServer& server, ConnectionInfo info, std::unique_ptr<AsioSocket<T>> so); void HttpCommTask<T>::start(); bool HttpCommTask<T>::readCallback(asio_ns::error_code ec); void HttpCommTask<T>::setIOTimeout(); void HttpCommTask<T>::checkVSTPrefix(); static void __attribute__((noinline); std::string HttpCommTask<T>::url(); void HttpCommTask<T>::processRequest(); void HttpCommTask<T>::doProcessRequest(); static void __attribute__((noinline); void HttpCommTask<T>::sendResponse(std::unique_ptr<GeneralResponse> baseRes, RequestStatistics::Item stat); static void __attribute__((noinline); static void __attribute__((noinline); void HttpCommTask<T>::writeResponse(RequestStatistics::Item stat); std::unique_ptr<GeneralResponse> HttpCommTask<T>::createResponse(rest::ResponseCode responseCode, uint64_t mid);

8f1d6b4ee149999bdaddd3d5fa55e86b8049239bf46622b0f100e2b538dbf5d6

biluna

biluna

gv/src/core/RBlockReferenceData.cpp

RBlockReferenceData::getCenterPoints

QList<RVector> RBlockReferenceData::getCenterPoints() const { QList<RVector> ret; return ret; }

RBlockReferenceData::RBlockReferenceData(); RVector RBlockReferenceData::getVectorTo(const RVector& point, bool limited); RBox RBlockReferenceData::getBoundingBox(); QList<RBox> RBlockReferenceData::getBoundingBoxes(); QSharedPointer<REntity> RBlockReferenceData::queryEntity(REntity::Id entityId); QList<RVector> RBlockReferenceData::getEndPoints(); QList<RVector> RBlockReferenceData::getMiddlePoints(); RVector RBlockReferenceData::getClosestPointOnEntity(const RVector& point); QList<RVector> RBlockReferenceData::getPointsWithDistanceToEnd(double distance); bool RBlockReferenceData::intersectsWith(const RTriangle& triangle); bool RBlockReferenceData::move(const RVector& offset); bool RBlockReferenceData::rotate(double rotation, const RVector& center); bool RBlockReferenceData::mirror(const RLine& axis); bool RBlockReferenceData::scale(const RVector& scaleFactors, const RVector& center); bool RBlockReferenceData::flipHorizontal(); bool RBlockReferenceData::flipVertical();

80dce4bff0efd2882c732ea8f125adaf243696e9a489862fa7e6ae672f53ed61

facebookresearch

faiss

tests/test_merge.cpp

Tempfilename

Tempfilename() { pthread_mutex_lock(&mutex); int fd = mkstemp(&filename[0]); close(fd); pthread_mutex_unlock(&mutex); }

~Tempfilename(); const char* c_str(); CommonData(); TEST(MERGE, merge_flat_no_ids); TEST(MERGE, merge_flat); TEST(MERGE, merge_flat_vt); TEST(MERGE, merge_flat_ondisk); TEST(MERGE, merge_flat_ondisk_2);

e164e1a059933ddb94d8f4e489bf588df218a48ea65880addb64977e0ef87f00

arcadenea

rockbot

build-Rockbot_Editor-Desktop-Debug/moc_editorarea.cpp

*EditorArea::metaObject

const QMetaObject *EditorArea::metaObject() const { return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject; }

void EditorArea::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a); void *EditorArea::qt_metacast(const char *_clname); int EditorArea::qt_metacall(QMetaObject::Call _c, int _id, void **_a);

9f5d48ee991ae180a5a6f7309b291ae9ae50f7685c4e60512f81c7fd4c39e7f4

FUKUZAWA-Tadashi

Hayat

engine/hyClosure.cpp

Closure::needSize

size_t Closure::needSize(hys32 numSharedLocal) { return sizeof(Closure) + sizeof(SharedLocal_st) * (numSharedLocal - 1); }

Closure* Closure::create(hyu8 numSharedLocal); void Closure::initialize(const MethodPtr& methodPtr, hyu8 numSharedlocal, hyu16 creatorMethodID); void Closure::setSharedLocal(hyu8 localIdx, Object* sharedLocalVar); void Closure::call(Context* context, hyu8 numArgs, bool bAway); void Closure::m_GC_mark(void);

054b6e2093afef1de47fc0340db3446df14e35748faf6e03cb469298610dab60

tedvals

mangosbot

src/test/HealPriestTestCase.cpp

racials

void racials() { engine->addStrategy("racials"); addPartyAura("power word: fortitude"); tickWithLowHealth(39); tickWithLowHealth(39); tickWithLowHealth(39); tickWithLowHealth(39); tickWithLowHealth(39); tickWithLowHealth(39); tickWithLowHealth(39); tick(); tickWithLowHealth(59); tickWithSpellAvailable("shoot"); assertActions(">S:lifeblood>S:gift of the naaru>S:power word: shield>S:greater heal>S:renew>S:heal>S:lesser heal>T:shoot>S:flash heal>T:shoot"); }

void setUp(); void healHimself(); void healOthers(); void aoe_heal(); void flee(); void cc(); void enemyTooClose(); void dispel(); void incompatibles(); void range();

8c3d23550512dff5e60a938e9878ffdb309ffbd1f1fee77254fc81058c78f865

sedna

sedna

kernel/tr/executor/fo/op_map.cpp

op_map_fn_compare_equal_collation

tuple_cell op_map_fn_compare_equal_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler) { return tuple_cell::atomic(fn_compare(a1, a2, handler) == 0); }

tuple_cell op_map_fn_compare_equal(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_not_equal(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_less_than(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_less_equal(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_greater_than(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_greater_equal(const tuple_cell &a1, const tuple_cell &a2); tuple_cell op_map_fn_compare_not_equal_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); tuple_cell op_map_fn_compare_less_than_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); tuple_cell op_map_fn_compare_less_equal_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); tuple_cell op_map_fn_compare_greater_than_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); tuple_cell op_map_fn_compare_greater_equal_collation(const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); int simple_type2bin_op_numeric_index(xmlscm_type xtype); int simple_type2bin_op_add_index(xmlscm_type xtype); int simple_type2bin_op_sub_index(xmlscm_type xtype); int simple_type2bin_op_mul_index(xmlscm_type xtype); int simple_type2bin_op_div_index(xmlscm_type xtype); int simple_type2bin_op_idiv_index(xmlscm_type xtype); int simple_type2bin_op_mod_index(xmlscm_type xtype); int simple_type2bin_op_eq_index(xmlscm_type xtype); int simple_type2bin_op_ne_index(xmlscm_type xtype); int simple_type2bin_op_gt_index(xmlscm_type xtype); int simple_type2bin_op_lt_index(xmlscm_type xtype); int simple_type2bin_op_ge_index(xmlscm_type xtype); int simple_type2bin_op_le_index(xmlscm_type xtype); const char* _op_numeric_binary_generic_err_c_str(xq_binary_op_type t); const char* _op_binary_generic_err_c_str(xq_binary_op_type t); tuple_cell _op_numeric_generic(xq_binary_op_type t, const tuple_cell &a1, const tuple_cell &a2); tuple_cell _op_generic(xq_binary_op_type t, const tuple_cell &a1, const tuple_cell &a2); tuple_cell _op_generic_collation(xq_binary_op_type t, const tuple_cell &a1, const tuple_cell &a2, CollationHandler* handler); get_binary_op_res get_binary_op_common_case(xq_binary_op_type t); get_binary_op_res get_binary_op(xq_binary_op_type t, xmlscm_type t1, xmlscm_type t2); int simple_type2un_op_numeric_index(xmlscm_type xtype); const char* _op_numeric_unary_generic_err_c_str(xq_unary_op_type t); const char* _op_unary_generic_err_c_str(xq_unary_op_type t); tuple_cell _op_generic(xq_unary_op_type t, const tuple_cell &a1, const char* (*err_msg_fun); un_op_tuple_cell get_unary_op(xq_unary_op_type t, xmlscm_type t1);

456626c03982047d0ed2ba1fed579bcc52063b866e9571ef195629f610c3fde8

AlvyPiper

MoreGreenTea

csgosdk/game/missionchooser/layout_system/tilegen_enum.cpp

CTilegenEnum::FindEntry

int CTilegenEnum::FindEntry( int nValue ) const { for ( int i = 0; i < m_Entries.Count(); ++ i ) { if ( m_Entries[i].m_nValue == nValue ) { return i; } } return -1; }

CTilegenEnum::CTilegenEnum(); bool CTilegenEnum::LoadFromKeyValues( KeyValues *pEnumKeyValues ); const char *CTilegenEnum::GetEnumStringFromValue( int nValue );

7aaec9b430a8f05dd212b6bd283efcd03e0c777ade7db38118a6b09be053a2ba

xaos-project

XaoS

src/ui-hlp/play.cpp

uih_playmorph

oid uih_playmorph(struct uih_context *uih, dialogparam *d) { if (uih->playstring != NULL) { seterr(TR("Error", "morph available only in animation replay")); return; } if (d[2].number <= 0 || d[3].number <= 0) { seterr(TR("Error", "morphview: Invalid viewpoint")); uih->playc->destination = uih->fcontext->currentformula->v; } uih->playc->source = uih->fcontext->s; uih->playc->destination.cr = d[0].number; uih->playc->destination.ci = d[1].number; uih->playc->destination.rr = d[2].number; uih->playc->destination.ri = d[3].number; uih->playc->morph = 1; }

tatic inline struct uih_line *uih_findkey(uih_context *c, int key); tatic inline void uih_removeline(uih_context *c, struct uih_line *l); oid uih_line(uih_context *c, dialogparam *d); oid uih_morphline(uih_context *c, dialogparam *d); oid uih_morphlastline(uih_context *c, dialogparam *d); oid uih_setkey(uih_context *c, int line); tatic void uih_stopmorphing(uih_context *c); oid uih_update_lines(uih_context *c); oid uih_clear_line(uih_context *c); oid uih_clear_lines(uih_context *c); oid uih_freecatalog(uih_context */*c*/); oid uih_setfont(struct uih_context */*uih*/); nt uih_loadcatalog(uih_context *c, const char *name); tatic void handler(void *userdata); tatic void handler1(void *userdata); oid uih_skipframe(struct uih_context *uih); nt uih_replayenable(struct uih_context *uih, xio_file f, xio_constpath filename, int animr); oid uih_replaydisable(struct uih_context *uih); tatic void skipblank(struct uih_context *uih); tatic int gettoken(struct uih_context *uih); tatic char *gettokenwr(struct uih_context *c); oid uih_play_formula(struct uih_context *uih, const char *fname); oid uih_playmove(struct uih_context *uih, number_t x, number_t y); oid uih_playmorphjulia(struct uih_context *uih, number_t x, number_t y); oid uih_playmorphangle(struct uih_context *uih, number_t angle); oid uih_playautorotate(struct uih_context *uih, int mode); oid uih_playfilter(struct uih_context *uih, dialogparam *p); oid uih_playdefpalette(struct uih_context *uih, int shift); oid uih_zoomcenter(struct uih_context *uih, number_t x, number_t y); oid uih_playtextpos(struct uih_context *uih, dialogparam *p); oid uih_playusleep(struct uih_context *uih, int time); oid uih_playtextsleep(struct uih_context *uih); oid uih_playwait(struct uih_context *uih); oid uih_playjulia(struct uih_context *uih, int julia); oid uih_playcalculate(struct uih_context *uih); oid uih_playzoom(struct uih_context *uih); oid uih_playunzoom(struct uih_context *uih); oid uih_playstop(struct uih_context *uih); oid uih_playmessage(struct uih_context *uih, char *name); oid uih_playload(struct uih_context *uih, xio_path file); tatic void uih_processcommand(struct uih_context *uih, int flags); oid uih_playupdate(struct uih_context *uih); oid uih_load(struct uih_context *uih, xio_file f, xio_constpath filename); oid uih_command(struct uih_context *uih, const char *command);

f5c87ed3e7c9204462e63a55422cc8a1b00c04416b75e396fa135ce58b6054d3

xbmcin

XBMCinTC

project/cmake/addons/build/peripheral.joystick/src/api/JoystickManager.cpp

CJoystickManager::TriggerScan

void CJoystickManager::TriggerScan(void) { if (m_scanner) m_scanner->TriggerScan(); }

bool operator(); void safe_delete(T*& pVal); void safe_delete_vector(std::vector<T*>& vec); CJoystickManager::CJoystickManager(void); CJoystickManager& CJoystickManager::Get(void); bool CJoystickManager::Initialize(IScannerCallback* scanner); void CJoystickManager::Deinitialize(void); bool CJoystickManager::PerformJoystickScan(JoystickVector& joysticks); JoystickPtr CJoystickManager::GetJoystick(unsigned int index); JoystickVector CJoystickManager::GetJoysticks(const ADDON::Joystick& joystickInfo); bool CJoystickManager::GetEvents(std::vector<ADDON::PeripheralEvent>& events); bool CJoystickManager::SendEvent(const ADDON::PeripheralEvent& event); void CJoystickManager::ProcessEvents(); const ButtonMap& CJoystickManager::GetButtonMap(const std::string& provider);

4a38989445e9837210d21ffd2e5967671335f6ad1164bce968d0a17c8c15de94

AlexGhiondea

coreclr

src/debug/ee/controller.cpp

DebuggerStepper::IsRangeAppropriate

bool DebuggerStepper::IsRangeAppropriate(ControllerStackInfo *info) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: info:0x%x \n", info)); if (m_range == NULL) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: m_range == NULL, returning FALSE\n")); return false; } FrameInfo *realFrame; #if defined(WIN64EXCEPTIONS) bool fActiveFrameIsFunclet = info->m_activeFrame.IsNonFilterFuncletFrame(); if (fActiveFrameIsFunclet) { realFrame = &(info->m_returnFrame); } else #endif { realFrame = &(info->m_activeFrame); } LOG((LF_CORDB,LL_INFO10000, "DS::IRA: info->m_activeFrame.fp:0x%x m_fp:0x%x\n", info->m_activeFrame.fp, m_fp)); LOG((LF_CORDB,LL_INFO10000, "DS::IRA: m_fdException:0x%x realFrame->md:0x%x realFrame->fp:0x%x m_fpException:0x%x\n", m_fdException, realFrame->md, realFrame->fp, m_fpException)); if ( (info->m_activeFrame.fp == m_fp) || ( (m_fdException != NULL) && (realFrame->md == m_fdException) && IsEqualOrCloserToRoot(realFrame->fp, m_fpException) ) ) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: returning TRUE\n")); return true; } #if defined(WIN64EXCEPTIONS) bool fValidParentMethodFP = (m_fpParentMethod != LEAF_MOST_FRAME); if (fActiveFrameIsFunclet) { if (m_fp == info->m_returnFrame.fp) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: returning TRUE\n")); return true; } else if (fValidParentMethodFP && (m_fpParentMethod == info->m_returnFrame.fp)) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: returning TRUE\n")); return true; } } else { if (fValidParentMethodFP && (m_fpParentMethod == info->m_activeFrame.fp)) { LOG((LF_CORDB,LL_INFO10000, "DS::IRA: returning TRUE\n")); return true; } } #endif LOG((LF_CORDB,LL_INFO10000, "DS::IRA: returning FALSE\n")); return false; }

bool DebuggerControllerPatch::IsSafeForStackTrace(); SharedPatchBypassBuffer* DebuggerControllerPatch::GetOrCreateSharedPatchBypassBuffer(); void DebuggerPatchTable::SortPatchIntoPatchList(DebuggerControllerPatch **ppPatch); void DebuggerPatchTable::SpliceOutOfList(DebuggerControllerPatch *patch); StackTraceTicket::StackTraceTicket(DebuggerControllerPatch * patch); StackTraceTicket::StackTraceTicket(ControllerStackInfo * info); StackTraceTicket::StackTraceTicket(const BYTE * ip); StackTraceTicket::StackTraceTicket(Thread * pThread); StackTraceTicket::StackTraceTicket(DebuggerUserBreakpoint * p); void ControllerStackInfo::SetReturnFrameWithActiveFrame(); StackWalkAction ControllerStackInfo::WalkStack(FrameInfo *pInfo, void *data); void DebuggerPatchTable::BindPatch(DebuggerControllerPatch *patch, CORDB_ADDRESS_TYPE *address); void DebuggerPatchTable::UnbindPatch(DebuggerControllerPatch *patch); void DebuggerPatchTable::RemovePatch(DebuggerControllerPatch *patch); DebuggerControllerPatch *DebuggerPatchTable::GetNextPatch(DebuggerControllerPatch *prev); void DebuggerPatchTable::CheckPatchTable(); int DebuggerPatchTable::GetNumberOfPatches(); void DebuggerController::EnsureUniqueThreadStarter(DebuggerThreadStarter * pNew); void DebuggerController::CancelOutstandingThreadStarter(Thread * pThread); HRESULT DebuggerController::Initialize(); DebuggerController::DebuggerController(Thread * pThread, AppDomain * pAppDomain); void DebuggerController::DeleteAllControllers(); DebuggerController::~DebuggerController(); void DebuggerController::Delete(); void DebuggerController::DebuggerDetachClean(); void DebuggerController::AddRef(DebuggerControllerPatch *patch); void DebuggerController::Release(DebuggerControllerPatch *patch); void DebuggerController::DisableAll(); void DebuggerController::Enqueue(); void DebuggerController::Dequeue(); bool DebuggerController::ApplyPatch(DebuggerControllerPatch *patch); bool DebuggerController::UnapplyPatch(DebuggerControllerPatch *patch); bool DebuggerController::IsPatched(CORDB_ADDRESS_TYPE *address, BOOL native); PRD_TYPE DebuggerController::GetPatchedOpcode(CORDB_ADDRESS_TYPE *address); void DebuggerController::ActivatePatch(DebuggerControllerPatch *patch); void DebuggerController::DeactivatePatch(DebuggerControllerPatch *patch); void DebuggerController::AddPatchToStartOfLatestMethod(MethodDesc * fd); void DebuggerController::RemovePatchesFromModule(Module *pModule, AppDomain *pAppDomain ); bool DebuggerController::ModuleHasPatches( Module* pModule ); static bool _AddrIsJITHelper(PCODE addr); DebuggerControllerPatch *DebuggerController::GetEnCPatch(const BYTE *address); DPOSS_ACTION DebuggerController::DispatchPatchOrSingleStep(Thread *thread, CONTEXT *context, CORDB_ADDRESS_TYPE *address, SCAN_TRIGGER which); bool DebuggerController::IsSingleStepEnabled(); void DebuggerController::EnableSingleStep(); BOOL DebuggerController::IsSingleStepEnabled(Thread *pThread); void DebuggerController::EnableSingleStep(Thread *pThread); void DebuggerController::DisableSingleStep(); void DebuggerController::ApplyTraceFlag(Thread *thread); void DebuggerController::UnapplyTraceFlag(Thread *thread); void DebuggerController::EnableExceptionHook(); void DebuggerController::DisableExceptionHook(); void DebuggerController::EnableUnwind(FramePointer fp); FramePointer DebuggerController::GetUnwind(); void DebuggerController::DisableUnwind(); void DebuggerController::EnableTraceCall(FramePointer maxFrame); VOID DebuggerController::PatchTargetVisitor(TADDR pVirtualTraceCallTarget, VOID* pUserData); void DebuggerController::DisableTraceCall(); FramePointer GetCurrentFramePointerFromStackTraceForTraceCall(Thread * thread); bool DebuggerController::IsMethodEnterEnabled(); void DebuggerController::EnableMethodEnter(); void DebuggerController::DisableMethodEnter(); void DebuggerController::DispatchMethodEnter(void * pIP, FramePointer fp); void DebuggerController::TriggerFuncEvalEnter(Thread * thread); void DebuggerController::TriggerFuncEvalExit(Thread * thread); bool DebuggerController::SendEvent(Thread *thread, bool fIpChanged); void DebuggerController::DispatchFuncEvalEnter(Thread * thread); void DebuggerController::DispatchFuncEvalExit(Thread * thread); void ThisFunctionMayHaveTriggerAGC(); DebuggerPatchSkip::~DebuggerPatchSkip(); void DebuggerPatchSkip::DebuggerDetachClean(); LONG FilterAccessViolation2(LPEXCEPTION_POINTERS ep, PVOID pv); void _CopyInstructionBlockHelper(BYTE* to, const BYTE* from); void DebuggerPatchSkip::CopyInstructionBlock(BYTE *to, const BYTE* from); bool DebuggerPatchSkip::TriggerSingleStep(Thread *thread, const BYTE *ip); bool DebuggerBreakpoint::SendEvent(Thread *thread, bool fIpChanged); DebuggerStepper::~DebuggerStepper(); bool DebuggerStepper::DetectHandleInterceptors(ControllerStackInfo *info); BOOL DebuggerStepper::DetectHandleLCGMethods(const PCODE ip, MethodDesc * pMD, ControllerStackInfo * pInfo); void DebuggerStepper::TriggerFuncEvalEnter(Thread * thread); void DebuggerStepper::TriggerFuncEvalExit(Thread * thread); void DebuggerStepper::EnableJMCBackStop(MethodDesc * pStartMethod); FORCEINLINE bool IsTailCall(const BYTE * pTargetIP); bool DebuggerStepper::TrapStep(ControllerStackInfo *info, bool in); void DebuggerStepper::TrapStepNext(ControllerStackInfo *info); bool DebuggerStepper::IsInterestingFrame(FrameInfo * pFrame); void DebuggerStepper::TrapStepOut(ControllerStackInfo *info, bool fForceTraditional); void DebuggerStepper::StepOut(FramePointer fp, StackTraceTicket ticket); bool DebuggerStepper::SetRangesFromIL(DebuggerJitInfo *dji, COR_DEBUG_STEP_RANGE *ranges, SIZE_T rangeCount); bool DebuggerStepper::DetectHandleNonUserCode(ControllerStackInfo *info, DebuggerMethodInfo * pInfo); void DebuggerStepper::EnablePolyTraceCall(); bool DebuggerStepper::TriggerSingleStep(Thread *thread, const BYTE *ip); void DebuggerStepper::TriggerTraceCall(Thread *thread, const BYTE *ip); void DebuggerStepper::PrepareForSendEvent(StackTraceTicket ticket); bool DebuggerStepper::SendEvent(Thread *thread, bool fIpChanged); void DebuggerStepper::ResetRange(); bool DebuggerStepper::IsFrozen(); bool DebuggerStepper::IsDead(); DebuggerJMCStepper::~DebuggerJMCStepper(); bool DebuggerJMCStepper::IsInterestingFrame(FrameInfo * pFrame); void DebuggerJMCStepper::TrapStepNext(ControllerStackInfo *info); void DebuggerJMCStepper::EnablePolyTraceCall(); bool DebuggerJMCStepper::DetectHandleNonUserCode(ControllerStackInfo *pInfo, DebuggerMethodInfo * dmi); CorDebugIntercept ConvertFrameBitsToDbg(Frame::Interception i); InterceptorStackInfo(); CorDebugIntercept GetInterceptorsInRange(); void Init(FramePointer fpTop, Thread *thread, CONTEXT *pContext, BOOL contextValid); static StackWalkAction WalkStack(FrameInfo *pInfo, void *data); bool DebuggerJMCStepper::DetectHandleInterceptors(ControllerStackInfo * info); DebuggerThreadStarter::DebuggerThreadStarter(Thread *thread); void DebuggerThreadStarter::TriggerTraceCall(Thread *thread, const BYTE *ip); bool DebuggerThreadStarter::SendEvent(Thread *thread, bool fIpChanged); bool DebuggerUserBreakpoint::IsFrameInDebuggerNamespace(FrameInfo * pFrame); static StackWalkAction WalkStackWrapper(FrameInfo *pInfo, void *data); StackWalkAction WalkStack(FrameInfo *pInfo); bool DoCheck(IN Thread * pThread); void DebuggerUserBreakpoint::HandleDebugBreak(Thread * pThread); DebuggerUserBreakpoint::DebuggerUserBreakpoint(Thread *thread); bool DebuggerUserBreakpoint::IsInterestingFrame(FrameInfo * pFrame); bool DebuggerUserBreakpoint::SendEvent(Thread *thread, bool fIpChanged); bool DebuggerFuncEvalComplete::SendEvent(Thread *thread, bool fIpChanged); bool DebuggerContinuableExceptionBreakpoint::SendEvent(Thread *thread, bool fIpChanged);

0c890a8abc70d4492e5aaeec60e9414b6fa3a1c9c329419b8ac51181a75c6177

cstipkovic

spidermonkey-research

js/src/asmjs/AsmJSValidate.cpp

addExportedChangeHeap

bool addExportedChangeHeap(PropertyName* name, const Global& g, PropertyName* maybeFieldName) { return module_->addExportedChangeHeap(name, g.changeHeapSrcBegin(), g.changeHeapSrcEnd(), maybeFieldName); }

void define(ParseNode* fn); FuncPtrTable(LifoAlloc& lifo, PropertyName* name, uint32_t firstUseOffset, LifoSignature* sig, uint32_t mask, uint32_t gdo, uint32_t tableIndex); Which which(); Type varOrConstType(); uint32_t varOrConstIndex(); bool isConst(); AsmJSNumLit constLiteralValue(); uint32_t funcIndex(); uint32_t funcPtrTableIndex(); unsigned ffiIndex(); bool isAnyArrayView(); Scalar::Type viewType(); bool viewIsSharedView(); void setViewIsSharedView(); bool isMathFunction(); AsmJSMathBuiltinFunction mathBuiltinFunction(); bool isAtomicsFunction(); AsmJSAtomicsBuiltinFunction atomicsBuiltinFunction(); bool isSimdCtor(); AsmJSSimdType simdCtorType(); bool isSimdOperation(); AsmJSSimdOperation simdOperation(); AsmJSSimdType simdOperationType(); uint32_t changeHeapSrcBegin(); uint32_t changeHeapSrcEnd(); explicit MathBuiltin(double cst); explicit MathBuiltin(AsmJSMathBuiltinFunction func); ArrayView(PropertyName* name, Scalar::Type type); ExitDescriptor(PropertyName* name, const LifoSignature* sig); PropertyName* name(); const LifoSignature& sig(); Lookup(PropertyName* name, const Signature* sig); static HashNumber hash(const Lookup& d); static bool match(const ExitDescriptor& lhs, const Lookup& rhs); SlowFunction(PropertyName* name, unsigned ms, unsigned line, unsigned column); ~ModuleValidator(); bool addStandardLibraryMathName(const char* name, double cst); bool addStandardLibraryAtomicsName(const char* name, AsmJSAtomicsBuiltinFunction func); bool addStandardLibrarySimdOpName(const char* name, AsmJSSimdOperation op); bool addGlobalVarInit(PropertyName* varName, const AsmJSNumLit& lit, bool isConst); bool addGlobalVarImport(PropertyName* varName, PropertyName* fieldName, AsmJSCoercion coercion, bool isConst); bool addArrayView(PropertyName* varName, Scalar::Type vt, PropertyName* maybeField, bool isSharedView); bool addMathBuiltinFunction(PropertyName* varName, AsmJSMathBuiltinFunction func, PropertyName* fieldName); bool addGlobalConstant(PropertyName* varName, double constant, PropertyName* fieldName); bool addAtomicsBuiltinFunction(PropertyName* varName, AsmJSAtomicsBuiltinFunction func, PropertyName* fieldName); bool addSimdCtor(PropertyName* varName, AsmJSSimdType type, PropertyName* fieldName); bool addSimdOperation(PropertyName* varName, AsmJSSimdType type, AsmJSSimdOperation op, PropertyName* typeVarName, PropertyName* opName); bool addByteLength(PropertyName* name); bool addChangeHeap(PropertyName* name, ParseNode* fn, uint32_t mask, uint32_t min, uint32_t max); bool addArrayViewCtor(PropertyName* varName, Scalar::Type vt, PropertyName* fieldName, bool isSharedView); bool addFFI(PropertyName* varName, PropertyName* field); bool addExportedFunction(const Func& func, PropertyName* maybeFieldName); bool addFunction(PropertyName* name, uint32_t firstUseOffset, Signature&& sig, Func** func); bool addFuncPtrTable(PropertyName* name, uint32_t offset, Signature&& sig, uint32_t mask, ModuleValidator::FuncPtrTable** table); bool addExit(unsigned ffiIndex, PropertyName* name, Signature&& sig, unsigned* exitIndex, const LifoSignature** lifoSig); bool tryOnceToValidateChangeHeap(); bool hasChangeHeap(); bool tryRequireHeapLengthToBeAtLeast(uint32_t len); uint32_t minHeapLength(); bool hasAlreadyFailed(); bool failOffset(uint32_t offset, const char* str); bool fail(ParseNode* pn, const char* str); bool failfVAOffset(uint32_t offset, const char* fmt, va_list ap); bool failfOffset(uint32_t offset, const char* fmt, ...); bool failf(ParseNode* pn, const char* fmt, ...); bool failNameOffset(uint32_t offset, const char* fmt, PropertyName* name); bool failName(ParseNode* pn, const char* fmt, PropertyName* name); bool failOverRecursed(); unsigned numArrayViews(); const ArrayView& arrayView(unsigned i); unsigned numFunctions(); Func& function(unsigned i); unsigned numFuncPtrTables(); FuncPtrTable& funcPtrTable(unsigned i); uint32_t functionEntryOffset(unsigned i); const Global* lookupGlobal(PropertyName* name); Func* lookupFunction(PropertyName* name); bool lookupStandardLibraryMathName(PropertyName* name, MathBuiltin* mathBuiltin); bool lookupStandardLibraryAtomicsName(PropertyName* name, AsmJSAtomicsBuiltinFunction* atomicsBuiltin); bool lookupStandardSimdOpName(PropertyName* name, AsmJSSimdOperation* op); bool finishGeneratingFunction(FunctionCompileResults& results); bool finishGeneratingEntry(unsigned exportIndex, Label* begin); bool finishGeneratingInterpExit(unsigned exitIndex, Label* begin, Label* profilingReturn); bool finishGeneratingJitExit(unsigned exitIndex, Label* begin, Label* profilingReturn); bool finishGeneratingInlineStub(Label* begin); bool finishGeneratingInterrupt(Label* begin, Label* profilingReturn); bool finishGeneratingBuiltinThunk(AsmJSExit::BuiltinKind builtin, Label* begin, Label* pret); bool finish(ScopedJSDeletePtr<AsmJSModule>* module); void startFunctionBodies(); bool finishFunctionBodies(ScopedJSDeletePtr<ModuleCompileResults>* compileResults); void buildCompilationTimeReport(JS::AsmJSCacheResult cacheResult, ScopedJSFreePtr<char>* out); ModuleCompileInputs compileInputs(); FunctionValidator(ModuleValidator& m, AsmFunction& func, ParseNode* fn); bool init(); bool fail(ParseNode* pn, const char* str); bool failf(ParseNode* pn, const char* fmt, ...); bool failName(ParseNode* pn, const char* fmt, PropertyName* name); bool addFormal(ParseNode* pn, PropertyName* name, VarType type); bool addVariable(ParseNode* pn, PropertyName* name, const AsmJSNumLit& init); void enterHeapExpression(); void leaveHeapExpression(); bool canCall(); bool hasAlreadyReturned(); RetType returnedType(); void setReturnedType(RetType retType); uint32_t lookupLabel(PropertyName* label); bool addLabel(PropertyName* label, uint32_t* id); void removeLabel(PropertyName* label); const Local* lookupLocal(PropertyName* name); const ModuleValidator::Global* lookupGlobal(PropertyName* name); bool startedPacking(); size_t writeOp(T op); void writeDebugCheckPoint(); size_t writeU8(uint8_t u); size_t writeU32(uint32_t u); size_t writeI32(int32_t u); void writeInt32Lit(int32_t i); void writeLit(AsmJSNumLit lit); void patchOp(size_t pos, T stmt); void patchU8(size_t pos, uint8_t u8); void patch32(size_t pos, T val); void patchSignature(size_t pos, const LifoSignature* ptr); size_t tempU8(); size_t tempOp(); size_t temp32(); size_t tempPtr(); bool operator(); explicit CheckSimdScalarArgs(AsmJSSimdType simdType); bool operator(); bool operator(); bool operator(); bool operator(); bool operator(); ~ParallelCompilationGuard(); bool claim(); explicit ParallelGroupState(Vector<AsmJSParallelTask>& tasks);

d332929dd1e71dbaeafef9b058624cf8b6797ac8c110bfc9a2343fd9521081f4

MIFOZ

Hieroglyph3-mirror

Source/Texture3dConfigDX11.cpp

Texture3dConfigDX11::SetWidth

void Texture3dConfigDX11::SetWidth( UINT state ) { m_State.Width = state; }

Texture3dConfigDX11::Texture3dConfigDX11(); Texture3dConfigDX11::~Texture3dConfigDX11(); void Texture3dConfigDX11::SetDefaults(); void Texture3dConfigDX11::SetHeight( UINT state ); void Texture3dConfigDX11::SetDepth( UINT state ); void Texture3dConfigDX11::SetMipLevels( UINT state ); void Texture3dConfigDX11::SetFormat( DXGI_FORMAT state ); void Texture3dConfigDX11::SetUsage( D3D11_USAGE state ); void Texture3dConfigDX11::SetBindFlags( UINT state ); void Texture3dConfigDX11::SetCPUAccessFlags( UINT state ); void Texture3dConfigDX11::SetMiscFlags( UINT state ); D3D11_TEXTURE3D_DESC Texture3dConfigDX11::GetTextureDesc();

60ddd03f5372fb4a6f300137cd2822285badefb730ffaad392e39a8d783c3284

AeanSR

simc

engine/class_modules/sc_priest.cpp

creator

haste_buff_creator_t creator(const special_effect_t& e) const override { return super::creator(e) .spell(e.trigger()) .cd(e.player->find_spell(226262)->duration()) .default_value(e.trigger()->effectN(2).percent()) .add_invalidate(CACHE_RUN_SPEED); }

resource_e primary_resource(); void do_dynamic_regen(); void generate_insanity( double num_amount, gain_t* g, action_t* action ); insanity_end_event_t( priest_t& actor_, const timespan_t& duration_ ); void execute(); insanity_state_t( priest_t& a ); void set_last_drained(); void begin_tracking(); timespan_t time_to_end(); void reset(); double insanity_drain_per_second(); void gain( double value, gain_t* gain_obj, action_t* source_action = nullptr ); void drain(); void adjust_end_event(); priest_pet_t( sim_t* sim, priest_t& owner, const std::string& pet_name, pet_e pt, bool guardian = false ); void init_base_stats(); void schedule_ready( timespan_t delta_time, bool waiting ); double composite_player_multiplier( school_e school ); resource_e primary_resource(); priest_t& o(); priest_pet_melee_t( priest_pet_t& p, const char* name ); void reset(); timespan_t execute_time(); void schedule_execute( action_state_t* state = nullptr ); priest_pet_spell_t( priest_pet_t& p, const std::string& n ); priest_pet_spell_t( const std::string& token, priest_pet_t* p, const spell_data_t* s = spell_data_t::nil(); priest_pet_t& p(); const priest_pet_t& p(); base_fiend_pet_t( sim_t* sim, priest_t& owner, pet_e pt, const std::string& name ); void create_buffs(); void init_gains(); void init_resources( bool force ); void summon( timespan_t duration ); void dismiss( bool expired ); shadowfiend_pet_t( sim_t* sim, priest_t& owner, const std::string& name = "shadowfiend" ); double mana_return_percent(); mindbender_pet_t( sim_t* sim, priest_t& owner, const std::string& name = "mindbender" ); double mana_return_percent(); shadowcrawl_t( base_fiend_pet_t& p ); base_fiend_pet_t& p(); const base_fiend_pet_t& p(); void execute(); fiend_melee_t( base_fiend_pet_t& p ); base_fiend_pet_t& p(); const base_fiend_pet_t& p(); double action_multiplier(); timespan_t execute_time(); void execute(); void impact( action_state_t* s ); void base_fiend_pet_t::init_action_list(); action_t* base_fiend_pet_t::create_action( const std::string& name, const std::string& options_str ); priest_action_t( const std::string& n, priest_t& p, const spell_data_t* s = spell_data_t::nil(); priest_td_t& get_td( player_t* t ); priest_td_t* find_td( player_t* t ); const priest_td_t* find_td( player_t* t ); bool trigger_shadowy_insight(); bool trigger_zeks(); void trigger_anunds(); double cost(); void consume_resource(); priest_absorb_t( const std::string& n, priest_t& player, const spell_data_t* s = spell_data_t::nil(); priest_heal_t( const std::string& n, priest_t& player, const spell_data_t* s = spell_data_t::nil(); double action_multiplier(); void execute(); void impact( action_state_t* s ); priest_spell_t( const std::string& n, priest_t& player, const spell_data_t* s = spell_data_t::nil(); bool usable_moving(); bool ready(); double composite_target_multiplier( player_t* t ); void impact( action_state_t* s ); void assess_damage( dmg_e type, action_state_t* s ); void trigger_vampiric_embrace( action_state_t* s ); angelic_feather_t( priest_t& p, const std::string& options_str ); void impact( action_state_t* s ); bool ready(); archangel_t( priest_t& p, const std::string& options_str ); void execute(); bool ready(); dispersion_t( priest_t& player, const std::string& options_str ); void execute(); timespan_t composite_dot_duration( const action_state_t* ); timespan_t tick_time( const action_state_t* ); void last_tick( dot_t* d ); divine_star_base_t( const std::string& n, priest_t& p, const spell_data_t* spell_data, bool is_return_spell = false ); void execute(); divine_star_t( priest_t& p, const std::string& options_str ); void execute(); halo_base_t( const std::string& n, priest_t& p, const spell_data_t* s ); timespan_t distance_targeting_travel_time( action_state_t* s ); double calculate_direct_amount( action_state_t* s ); halo_t( priest_t& p, const std::string& options_str ); void execute(); holy_fire_base_t( const std::string& name, priest_t& p, const spell_data_t* sd ); void execute(); double action_multiplier(); holy_fire_t( priest_t& player, const std::string& options_str ); levitate_t( priest_t& p, const std::string& options_str ); mind_blast_t( priest_t& player, const std::string& options_str ); void init(); void schedule_execute( action_state_t* s ); void execute(); double composite_da_multiplier(const action_state_t* state); void impact( action_state_t* s ); timespan_t execute_time(); timespan_t cooldown_base_duration( const cooldown_t& cooldown ); void update_ready( timespan_t cd_duration ); mind_sear_tick_t( priest_t& p ); size_t available_targets( std::vector<player_t*>& tl ); void trigger( player_t* target ); void impact( action_state_t* state ); new_void_tendril_mind_flay_t(priest_t& p); timespan_t tick_time(const action_state_t*); double composite_da_multiplier(const action_state_t* state); void impact(action_state_t* s); mind_flay_t( priest_t& p, const std::string& options_str ); double action_multiplier(); void spread_twins_painsful_dots( action_state_t* s ); void tick( dot_t* d ); void impact( action_state_t* s ); pain_suppression_t( priest_t& p, const std::string& options_str ); void execute(); penance_tick_t( priest_t& p, stats_t* stats ); bool verify_actor_level(); void impact( action_state_t* state ); penance_t( priest_t& p, const std::string& options_str ); timespan_t tick_time( const action_state_t* ); void execute(); power_infusion_t( priest_t& p, const std::string& options_str ); void execute(); power_word_solace_t( priest_t& player, const std::string& options_str ); void impact( action_state_t* s ); purge_the_wicked_dot_t( priest_t& p ); purge_the_wicked_t( priest_t& p, const std::string& options_str ); schism_t( priest_t& player, const std::string& options_str ); void impact( action_state_t* s ); shadow_word_death_t( priest_t& p, const std::string& options_str ); double composite_da_multiplier( const action_state_t* state ); void impact( action_state_t* s ); bool ready(); shadow_crash_t( priest_t& p, const std::string& options_str ); void execute(); shadowform_t( priest_t& p, const std::string& options_str ); void execute(); shadowy_apparition_spell_t( priest_t& p ); void impact( action_state_t* s ); double composite_da_multiplier( const action_state_t* state ); void trigger(); blessed_dawnlight_medallion_t( priest_t& p, const special_effect_t& ); void execute(); sphere_of_insanity_spell_t( priest_t& p ); std::vector<player_t*>& target_list(); shadow_word_pain_t( priest_t& p, const std::string& options_str, bool _casted = true ); double spell_direct_power_coefficient( const action_state_t* s ); void impact( action_state_t* s ); void last_tick( dot_t* d ); void tick( dot_t* d ); double cost(); double action_multiplier(); shadow_word_void_t( priest_t& player, const std::string& options_str ); void impact( action_state_t* s ); void update_ready( timespan_t cd_duration ); silence_t( priest_t& player, const std::string& options_str ); void execute(); void impact(action_state_t* state); bool ready(); mind_bomb_t(priest_t& player, const std::string& options_str); void impact(action_state_t* state); bool ready(); smite_t( priest_t& p, const std::string& options_str ); void execute(); summon_pet_t( const std::string& n, priest_t& p, const spell_data_t* sd = spell_data_t::nil(); bool init_finished(); void execute(); bool ready(); summon_shadowfiend_t( priest_t& p, const std::string& options_str ); summon_mindbender_t( priest_t& p, const std::string& options_str ); surrender_to_madness_t( priest_t& p, const std::string& options_str ); void execute(); vampiric_embrace_t( priest_t& p, const std::string& options_str ); void execute(); bool ready(); vampiric_touch_t( priest_t& p, const std::string& options_str ); void trigger_heal( action_state_t* s ); void impact( action_state_t* s ); void tick( dot_t* d ); double action_multiplier(); void_bolt_extension_t( priest_t& player ); virtual timespan_t travel_time(); void impact( action_state_t* s ); void_bolt_t( priest_t& player, const std::string& options_str ); void execute(); bool ready(); double action_multiplier(); void impact( action_state_t* s ); void_eruption_t( priest_t& p, const std::string& options_str ); double spell_direct_power_coefficient( const action_state_t* ); void init(); std::vector<player_t*>& target_list(); void execute(); double composite_da_multiplier(const action_state_t* state); bool ready(); void_torrent_t( priest_t& p, const std::string& options_str ); timespan_t composite_dot_duration( const action_state_t* ); timespan_t tick_time( const action_state_t* ); void last_tick( dot_t* d ); void execute(); bool ready(); power_word_shield_t( priest_t& p, const std::string& options_str ); void impact( action_state_t* s ); mental_fortitude_t( priest_t& p ); void impact( action_state_t* s ); void assess_damage( dmg_e, action_state_t* s ); void spells::vampiric_touch_t::init_mental_fortitude(); priest_buff_t( priest_td_t& p, const Buff_Creator& params ); priest_buff_t( priest_t& p, const Buff_Creator& params ); priest_td_t& get_td( player_t* t ); stack_increase_event_t( insanity_drain_stacks_t* s ); const char* name(); void execute(); insanity_drain_stacks_t( priest_t& p ); bool trigger( int stacks, double value, double chance, timespan_t duration ); void expire_override( int expiration_stacks, timespan_t remaining_duration ); void bump( int stacks, double /* value */ ); void reset(); voidform_t( priest_t& p ); bool trigger( int stacks, double value, double chance, timespan_t duration ); bool freeze_stacks(); void expire_override( int expiration_stacks, timespan_t remaining_duration ); surrender_to_madness_t( priest_t& p ); void expire_override( int expiration_stacks, timespan_t remaining_duration ); lingering_insanity_t( priest_t& p ); void decrement( int, double ); void expire_override( int stacks, timespan_t ); archangel_t( priest_t& p ); bool trigger( int stacks, double /* value */, double chance, timespan_t duration ); void discipline_trinket( special_effect_t& effect ); void holy_trinket( special_effect_t& effect ); void shadow_trinket( special_effect_t& effect ); void anunds_seared_shackles( special_effect_t& effect ); void mangazas_madness( special_effect_t& effect ); void mother_shahrazs_seduction( special_effect_t& effect ); void the_twins_painful_touch( special_effect_t& effect ); void zenkaram_iridis_anadem( special_effect_t& effect ); void zeks_exterminatus( special_effect_t& effect ); void heart_of_the_void(special_effect_t& effect); void manipulate(priest_t* shaman, const special_effect_t& e); haste_buff_t*& buff_ptr(const special_effect_t& e); void init(); priest_td_t::priest_td_t( player_t* target, priest_t& p ); void priest_td_t::reset(); void priest_td_t::target_demise(); priest_t::priest_t( sim_t* sim, const std::string& name, race_e r ); void priest_t::create_cooldowns(); void priest_t::create_gains(); void priest_t::create_procs(); void priest_t::create_benefits(); role_e priest_t::primary_role(); stat_e priest_t::convert_hybrid_stat( stat_e s ); expr_t* priest_t::create_expression( action_t* a, const std::string& name_str ); void priest_t::assess_damage( school_e school, dmg_e dtype, action_state_t* s ); double priest_t::composite_spell_haste(); double priest_t::composite_melee_haste(); double priest_t::composite_spell_speed(); double priest_t::composite_melee_speed(); double priest_t::composite_player_pet_damage_multiplier(const action_state_t* state); double priest_t::composite_player_multiplier( school_e school ); double priest_t::composite_player_heal_multiplier( const action_state_t* s ); double priest_t::composite_player_absorb_multiplier( const action_state_t* s ); double priest_t::composite_player_target_multiplier( player_t* t, school_e school ); double priest_t::matching_gear_multiplier( attribute_e attr ); action_t* priest_t::create_action( const std::string& name, const std::string& options_str ); pet_t* priest_t::create_pet( const std::string& pet_name, const std::string& /* pet_type */ ); void priest_t::create_pets(); void priest_t::init_base_stats(); void priest_t::init_resources( bool force ); void priest_t::init_scaling(); void priest_t::init_spells(); void priest_t::create_buffs(); void priest_t::init_rng(); void priest_t::apl_precombat(); bool priest_t::has_t18_class_trinket(); void priest_t::trigger_call_to_the_void(const dot_t* d); void priest_t::trigger_sephuzs_secret(const action_state_t * state, spell_mechanic mechanic, double proc_chance); void priest_t::apl_default(); void priest_t::apl_shadow(); void priest_t::apl_disc_heal(); void priest_t::apl_disc_dmg(); void priest_t::apl_holy_heal(); void priest_t::apl_holy_dmg(); priest_td_t* priest_t::get_target_data( player_t* target ); priest_td_t* priest_t::find_target_data( player_t* target ); void priest_t::init_action_list(); void priest_t::combat_begin(); void priest_t::reset(); void priest_t::fixup_atonement_stats( const std::string& trigger_spell_name, const std::string& atonement_spell_name ); void priest_t::pre_analyze_hook(); void priest_t::target_mitigation( school_e school, dmg_e dt, action_state_t* s ); action_t* priest_t::create_proc_action( const std::string& /*name*/, const special_effect_t& effect ); void priest_t::create_options(); std::string priest_t::create_profile( save_e type ); void priest_t::copy_from( player_t* source ); priest_report_t( priest_t& player ); void html_customsection( report::sc_html_stream& /* os*/ ); priest_module_t(); player_t* create_player( sim_t* sim, const std::string& name, race_e r = RACE_NONE ); bool valid(); void init( player_t* p ); void static_init(); void register_hotfixes(); void combat_begin( sim_t* ); void combat_end( sim_t* ); const module_t* module_t::priest();

3bf3efb0bdc4f284ade91fc577559a10cf1cacfab0b7bcd15c1b5aa3cad68ca9

blefaudeux

RBDOOM-3-BFG

neo/d3xp/Player.cpp

idPlayer::Event_StartWarp

void idPlayer::Event_StartWarp() { playerView.AddWarp( idVec3( 0, 0, 0 ), SCREEN_WIDTH / 2, SCREEN_HEIGHT / 2, 100, 1000 ); }

void idInventory::Clear(); void idInventory::GivePowerUp( idPlayer* player, int powerup, int msec ); void idInventory::ClearPowerUps(); void idInventory::GetPersistantData( idDict& dict ); void idInventory::RestoreInventory( idPlayer* owner, const idDict& dict ); void idInventory::Save( idSaveGame* savefile ); void idInventory::Restore( idRestoreGame* savefile ); ammo_t idInventory::AmmoIndexForAmmoClass( const char* ammo_classname ); int idInventory::MaxAmmoForAmmoClass( const idPlayer* owner, const char* ammo_classname ); const char* idInventory::AmmoPickupNameForIndex( ammo_t ammonum ); int idInventory::WeaponIndexForAmmoClass( const idDict& spawnArgs, const char* ammo_classname ); ammo_t idInventory::AmmoIndexForWeaponClass( const char* weapon_classname, int* ammoRequired ); void idInventory::AddPickupName( const char* name, idPlayer* owner ); void idInventory::Drop( const idDict& spawnArgs, const char* weapon_classname, int weapon_index ); int idInventory::HasAmmo( ammo_t type, int amount ); int idInventory::HasAmmo( const char* weapon_classname, bool includeClip, idPlayer* owner ); bool idInventory::HasEmptyClipCannotRefill( const char* weapon_classname, idPlayer* owner ); bool idInventory::UseAmmo( ammo_t type, int amount ); void idInventory::UpdateArmor(); void idInventory::InitRechargeAmmo( idPlayer* owner ); void idInventory::RechargeAmmo( idPlayer* owner ); bool idInventory::CanGive( idPlayer* owner, const idDict& spawnArgs, const char* statname, const char* value ); void idInventory::SetClipAmmoForWeapon( const int weapon, const int amount ); void idInventory::SetInventoryAmmoForType( int ammoType, const int amount ); int idInventory::GetClipAmmoForWeapon( const int weapon ); int idInventory::GetInventoryAmmoForType( const int ammoType ); void idInventory::WriteAmmoToSnapshot( idBitMsg& msg ); void idInventory::ReadAmmoFromSnapshot( const idBitMsg& msg, const int ownerEntityNumber ); void idInventory::SetRemoteClientAmmo( const int ownerEntityNumber ); idPlayer::idPlayer(); void idPlayer::LinkScriptVariables(); void idPlayer::SetupWeaponEntity(); void idPlayer::Init(); void idPlayer::Spawn(); idPlayer::~idPlayer(); void idPlayer::Save( idSaveGame* savefile ); void idPlayer::Restore( idRestoreGame* savefile ); void idPlayer::PrepareForRestart(); void idPlayer::Restart(); void idPlayer::ServerSpectate( bool spectate ); void idPlayer::SelectInitialSpawnPoint( idVec3& origin, idAngles& angles ); void idPlayer::SpawnFromSpawnSpot(); void idPlayer::SpawnToPoint( const idVec3& spawn_origin, const idAngles& spawn_angles ); void idPlayer::Respawn_Shared(); void idPlayer::SavePersistantInfo(); void idPlayer::RestorePersistantInfo(); void idPlayer::UpdateSkinSetup(); void idPlayer::UpdateHudStats( idMenuHandler_HUD* _hudManager ); void idPlayer::UpdateHudWeapon( bool flashWeapon ); void idPlayer::UpdateChattingHud(); void idPlayer::UpdateSpectatingText(); void idPlayer::AddChatMessage( int index, int alpha, const idStr& message ); void idPlayer::ClearChatMessage( int index ); void idPlayer::DrawHUD( idMenuHandler_HUD* _hudManager ); void idPlayer::EnterCinematic(); void idPlayer::ExitCinematic(); void idPlayer::UpdateConditions(); void idPlayer::WeaponFireFeedback( const idDict* weaponDef ); void idPlayer::StopFiring(); void idPlayer::FireWeapon(); void idPlayer::CacheWeapons(); void idPlayer::SetQuickSlot( int index, int val ); int idPlayer::GetQuickSlot( int index ); bool idPlayer::Give( const char* statname, const char* value, unsigned int giveFlags ); void idPlayer::GiveHealthPool( float amt ); bool idPlayer::GiveItem( idItem* item, unsigned int giveFlags ); float idPlayer::PowerUpModifier( int type ); bool idPlayer::PowerUpActive( int powerup ); bool idPlayer::GivePowerUp( int powerup, int time, unsigned int giveFlags ); void idPlayer::ClearPowerup( int i ); void idPlayer::UpdatePowerUps(); void idPlayer::ClearPowerUps(); bool idPlayer::GiveInventoryItem( idDict* item, unsigned int giveFlags ); bool idPlayer::GiveInventoryItem( const char* name ); void idPlayer::GiveObjective( const char* title, const char* text, const idMaterial* screenshot ); void idPlayer::CompleteObjective( const char* title ); void idPlayer::GiveVideo( const idDeclVideo* video, const char* itemName ); void idPlayer::GiveSecurity( const char* security ); void idPlayer::GiveEmail( const idDeclEmail* email ); void idPlayer::GivePDA( const idDeclPDA* pda, const char* securityItem ); idDict* idPlayer::FindInventoryItem( const char* name ); idDict* idPlayer::FindInventoryItem( int index ); int idPlayer::GetNumInventoryItems(); void idPlayer::RemoveInventoryItem( const char* name ); void idPlayer::RemoveInventoryItem( idDict* item ); void idPlayer::GiveItem( const char* itemname ); int idPlayer::SlotForWeapon( const char* weaponName ); void idPlayer::Reload(); void idPlayer::NextBestWeapon(); void idPlayer::NextWeapon(); void idPlayer::PrevWeapon(); void idPlayer::SelectWeapon( int num, bool force ); void idPlayer::DropWeapon( bool died ); void idPlayer::StealWeapon( idPlayer* player ); idUserInterface* idPlayer::ActiveGui(); void idPlayer::Weapon_Combat(); void idPlayer::Weapon_NPC(); void idPlayer::LowerWeapon(); void idPlayer::RaiseWeapon(); void idPlayer::WeaponLoweringCallback(); void idPlayer::WeaponRisingCallback(); void idPlayer::Weapon_GUI(); void idPlayer::UpdateWeapon(); void idPlayer::UpdateFlashlight(); void idPlayer::FlashlightOn(); void idPlayer::FlashlightOff(); void idPlayer::SpectateFreeFly( bool force ); void idPlayer::SpectateCycle(); void idPlayer::UpdateSpectating(); bool idPlayer::HandleSingleGuiCommand( idEntity* entityGui, idLexer* src ); void idPlayer::PlayAudioLog( const idSoundShader* shader ); void idPlayer::EndAudioLog(); void idPlayer::PlayVideoDisk( const idDeclVideo* decl ); void idPlayer::EndVideoDisk(); bool idPlayer::Collide( const trace_t& collision, const idVec3& velocity ); void idPlayer::UpdateLocation(); void idPlayer::ClearFocus(); void idPlayer::UpdateFocus(); void idPlayer::CrashLand( const idVec3& oldOrigin, const idVec3& oldVelocity ); void idPlayer::BobCycle( const idVec3& pushVelocity ); void idPlayer::UpdateDeltaViewAngles( const idAngles& angles ); void idPlayer::SetViewAngles( const idAngles& angles ); void idPlayer::UpdateViewAngles(); void idPlayer::AdjustHeartRate( int target, float timeInSecs, float delay, bool force ); int idPlayer::GetBaseHeartRate(); void idPlayer::SetCurrentHeartRate(); void idPlayer::UpdateAir(); void idPlayer::UpdatePowerupHud(); const idDeclPDA* idPlayer::GetPDA(); const idDeclVideo* idPlayer::GetVideo( int index ); void idPlayer::TogglePDA(); void idPlayer::Spectate( bool spectate, bool force ); void idPlayer::SetClipModel(); void idPlayer::UseVehicle(); void idPlayer::PerformImpulse( int impulse ); void idPlayer::EvaluateControls(); void idPlayer::AdjustSpeed(); void idPlayer::AdjustBodyAngles(); void idPlayer::InitAASLocation(); void idPlayer::SetAASLocation(); void idPlayer::GetAASLocation( idAAS* aas, idVec3& pos, int& areaNum ); void idPlayer::Move_Interpolated( float fraction ); void idPlayer::Move(); bool idPlayer::AllowClientAuthPhysics(); void idPlayer::RunPhysics_RemoteClientCorrection(); int idPlayer::GetPhysicsTimeStep(); void idPlayer::ShowRespawnHudMessage(); void idPlayer::HideRespawnHudMessage(); void idPlayer::UpdateHud(); void idPlayer::UpdateDeathSkin( bool state_hitch ); void idPlayer::StartFxOnBone( const char* fx, const char* bone ); bool idPlayer::HandleGuiEvents( const sysEvent_t* ev ); void idPlayer::UpdateLaserSight(); void idPlayer::Think(); void idPlayer::StartHealthRecharge( int speed ); void idPlayer::StopHealthRecharge(); idStr idPlayer::GetCurrentWeapon(); bool idPlayer::CanGive( const char* statname, const char* value ); void idPlayer::StopHelltime( bool quick ); void idPlayer::Event_ToggleBloom( int on ); void idPlayer::Event_SetBloomParms( float speed, float intensity ); void idPlayer::PlayHelltimeStopSound(); void idPlayer::RouteGuiMouse( idUserInterface* gui ); void idPlayer::LookAtKiller( idEntity* inflictor, idEntity* attacker ); void idPlayer::Kill( bool delayRespawn, bool nodamage ); void idPlayer::Killed( idEntity* inflictor, idEntity* attacker, int damage, const idVec3& dir, int location ); void idPlayer::GetAIAimTargets( const idVec3& lastSightPos, idVec3& headPos, idVec3& chestPos ); void idPlayer::DamageFeedback( idEntity* victim, idEntity* inflictor, int& damage ); void idPlayer::ControllerShakeFromDamage( int damage ); int idPlayer::AdjustDamageAmount( const int inputDamage ); void idPlayer::ServerDealDamage( int damage, idEntity& inflictor, idEntity& attacker, const idVec3& dir, const char* damageDefName, const int location ); void idPlayer::Teleport( const idVec3& origin, const idAngles& angles, idEntity* destination ); void idPlayer::SetPrivateCameraView( idCamera* camView ); float idPlayer::DefaultFov(); float idPlayer::CalcFov( bool honorZoom ); idAngles idPlayer::GunTurningOffset(); idVec3 idPlayer::GunAcceleratingOffset(); void idPlayer::CalculateViewWeaponPos( idVec3& origin, idMat3& axis ); void idPlayer::OffsetThirdPersonView( float angle, float range, float height, bool clip ); idVec3 idPlayer::GetEyePosition(); void idPlayer::GetViewPos( idVec3& origin, idMat3& axis ); void idPlayer::CalculateFirstPersonView(); renderView_t* idPlayer::GetRenderView(); void idPlayer::CalculateRenderView(); void idPlayer::AddAIKill(); void idPlayer::SetSoulCubeProjectile( idProjectile* projectile ); void idPlayer::AddProjectilesFired( int count ); void idPlayer::AddProjectileHits( int count ); void idPlayer::SetLastHitTime( int time ); void idPlayer::SetInfluenceLevel( int level ); void idPlayer::SetInfluenceView( const char* mtr, const char* skinname, float radius, idEntity* ent ); void idPlayer::SetInfluenceFov( float fov ); bool idPlayer::OnLadder(); void idPlayer::Event_GetButtons(); void idPlayer::Event_GetMove(); void idPlayer::Event_GetViewAngles(); void idPlayer::Event_StopFxFov(); void idPlayer::StartFxFov( float duration ); void idPlayer::Event_EnableWeapon(); void idPlayer::Event_DisableWeapon(); void idPlayer::Event_GiveInventoryItem( const char* name ); void idPlayer::Event_RemoveInventoryItem( const char* name ); void idPlayer::Event_GetIdealWeapon(); void idPlayer::Event_SetPowerupTime( int powerup, int time ); void idPlayer::Event_IsPowerupActive( int powerup ); void idPlayer::Event_StopHelltime( int mode ); void idPlayer::Event_WeaponAvailable( const char* name ); bool idPlayer::WeaponAvailable( const char* name ); void idPlayer::Event_GetCurrentWeapon(); void idPlayer::Event_GetPreviousWeapon(); void idPlayer::Event_SelectWeapon( const char* weaponName ); void idPlayer::Event_GetWeaponEntity(); void idPlayer::Event_OpenPDA(); void idPlayer::Event_InPDA(); void idPlayer::TeleportDeath( int killer ); void idPlayer::Event_ForceOrigin( idVec3& origin, idAngles& angles ); void idPlayer::Event_ExitTeleporter(); void idPlayer::ClientThink( const int curTime, const float fraction, const bool predict ); bool idPlayer::GetPhysicsToVisualTransform( idVec3& origin, idMat3& axis ); bool idPlayer::GetPhysicsToSoundTransform( idVec3& origin, idMat3& axis ); void idPlayer::HandleUserCmds( const usercmd_t& newcmd ); void idPlayer::WriteToSnapshot( idBitMsg& msg ); void idPlayer::ReadFromSnapshot( const idBitMsg& msg ); void idPlayer::WritePlayerStateToSnapshot( idBitMsg& msg ); void idPlayer::ReadPlayerStateFromSnapshot( const idBitMsg& msg ); bool idPlayer::ServerReceiveEvent( int event, int time, const idBitMsg& msg ); bool idPlayer::ClientReceiveEvent( int event, int time, const idBitMsg& msg ); void idPlayer::Hide(); void idPlayer::Show(); bool idPlayer::IsSoundChannelPlaying( const s_channelType channel ); void idPlayer::ShowTip( const char* title, const char* tip, bool autoHide ); void idPlayer::HideTip(); void idPlayer::Event_HideTip(); void idPlayer::HideObjective(); void idPlayer::Event_StopAudioLog(); void idPlayer::SetSpectateOrigin(); void idPlayer::RemoveWeapon( const char* weap ); void idPlayer::RemoveAllButEssentialWeapons(); bool idPlayer::CanShowWeaponViewmodel(); void idPlayer::SetLevelTrigger( const char* levelName, const char* triggerName ); void idPlayer::Event_LevelTrigger(); void idPlayer::Event_Gibbed(); void idPlayer::UpdatePlayerIcons(); void idPlayer::DrawPlayerIcons(); void idPlayer::HidePlayerIcons(); bool idPlayer::NeedsIcon(); void idPlayer::DropFlag(); void idPlayer::ReturnFlag(); void idPlayer::FreeModelDef(); void idPlayer::SetControllerShake( float highMagnitude, int highDuration, float lowMagnitude, int lowDuration ); void idPlayer::ResetControllerShake(); void idPlayer::GetControllerShake( int& highMagnitude, int& lowMagnitude ); gameExpansionType_t idPlayer::GetExpansionType();

f445d016c5b7a9ecf10cefeced6e21c2c0b5671f30e5dca8f517da7228fda1dd

aws

aws-sdk-cpp

aws-cpp-sdk-chime-sdk-identity/source/model/ServiceFailureException.cpp

=

erviceFailureException& ServiceFailureException::operator =(JsonView jsonValue) { if(jsonValue.ValueExists("Code")) { m_code = ErrorCodeMapper::GetErrorCodeForName(jsonValue.GetString("Code")); m_codeHasBeenSet = true; } if(jsonValue.ValueExists("Message")) { m_message = jsonValue.GetString("Message"); m_messageHasBeenSet = true; } return *this; }

erviceFailureException::ServiceFailureException(); erviceFailureException::ServiceFailureException(JsonView jsonValue); sonValue ServiceFailureException::Jsonize();

a592305f63695e6861efbccb8159e4c40b261ffbd32ad96e2844e29ce2151edc

RoboMod

network-manager-ipop

kde/libs/internals/setting.cpp

Setting::typeFromString

Setting::Type Setting::typeFromString(const QString & typeString) { Setting::Type type = Wired; if (typeString == QLatin1String(NM_SETTING_CDMA_SETTING_NAME)) { type = Cdma; } else if (typeString == QLatin1String(NM_SETTING_GSM_SETTING_NAME)) { type = Gsm; } else if (typeString == QLatin1String(NM_SETTING_BLUETOOTH_SETTING_NAME)) { type = Bluetooth; } else if (typeString == QLatin1String(NM_SETTING_IP4_CONFIG_SETTING_NAME)) { type = Ipv4; } else if (typeString == QLatin1String(NM_SETTING_IP6_CONFIG_SETTING_NAME)) { type = Ipv6; } else if (typeString == QLatin1String(NM_SETTING_PPP_SETTING_NAME)) { type = Ppp; } else if (typeString == QLatin1String(NM_SETTING_PPPOE_SETTING_NAME)) { type = Pppoe; } else if (typeString == QLatin1String(NM_SETTING_SERIAL_SETTING_NAME)) { type = Serial; } else if (typeString == QLatin1String(NM_SETTING_802_1X_SETTING_NAME)) { type = Security8021x; } else if (typeString == QLatin1String(NM_SETTING_VPN_SETTING_NAME)) { type = Vpn; } else if (typeString == QLatin1String(NM_SETTING_WIRED_SETTING_NAME)) { type = Wired; } else if (typeString == QLatin1String(NM_SETTING_WIRELESS_SETTING_NAME)) { type = Wireless; } else if (typeString == QLatin1String(NM_SETTING_WIRELESS_SECURITY_SETTING_NAME)) { type = WirelessSecurity; } return type; }

QString Setting::typeAsString(Setting::Type type); Setting::Setting(Setting::Type type); Setting::Setting(Setting *setting); Setting::~Setting(); bool Setting::isNull(); void Setting::setInitialized(bool initialized); Setting::Type Setting::type(); bool Setting::secretsAvailable(); void Setting::setSecretsAvailable(bool available); QMap<QString,QString> Setting::secretsToMap(); void Setting::secretsFromMap(QMap<QString,QString> secrets); bool Setting::hasPersistentSecrets(); QStringList Setting::needSecrets(const bool /*requestNew*/);

ada3044da22225c5ceb12e4e7bdb8fb22698cb2c69d89d20cf0bd83836793d67

GuapoTaco

Wallpaper-gen

GLWidget.cpp

GLWidget::event

bool GLWidget::event (QEvent* event) { switch(event->type()) { case QEvent::Type::MouseButtonPress: { auto mousePressEvent = static_cast<QMouseEvent*>(event); if(mousePressEvent->button() == Qt::LeftButton) { isMouseDown = true; lastMousePos = { mousePressEvent->x(), mousePressEvent->y() }; return true; } } break; case QEvent::Type::MouseButtonRelease: { auto mousePressEvent = static_cast<QMouseEvent*>(event); if(mousePressEvent->button() == Qt::LeftButton) { isMouseDown = false; return true; } } break; case QEvent::Type::MouseMove: { auto mousePressEvent = static_cast<QMouseEvent*>(event); if(isMouseDown) { glm::ivec2 currentMouse = { mousePressEvent->x(), mousePressEvent->y() }; glm::ivec2 deltaMouse = currentMouse - lastMousePos; auto forVecIntX = glm::rotate((float)deltaMouse.x / 1000.f, glm::vec3{0.f, 0.f, 1.f}) * glm::vec4(forwardVector, 0.f); forwardVector = {forVecIntX.x, forVecIntX.y, forVecIntX.z}; auto forVecIntY = glm::rotate(-(float)deltaMouse.y / 1000.f, glm::vec3{1.f, 0.f, 0.f}) * glm::vec4(forwardVector, 0.f); forwardVector = {forVecIntY.x, forVecIntY.y, forVecIntY.z}; lastMousePos = currentMouse; return true; } } break; default: break; } return QOpenGLWidget::event(event); }

GLWidget::GLWidget ( Window* parent, Qt::WindowFlags f ); std::array<float, 3> fromRGB(unsigned char r, unsigned char g, unsigned char b); void GLWidget::markForRegeneration(); void GLWidget::markForSave(const QString& saveDest); void GLWidget::markForColorRefresh(); std::array<float, 3> fromHex(uint32_t color); void GLWidget::keyPressEvent ( QKeyEvent* event ); void GLWidget::keyReleaseEvent ( QKeyEvent* event ); void GLWidget::initializeGL(); void GLWidget::paintGL(); void GLWidget::regenerate(); void GLWidget::saveImageOut();

0cd66b5fe6e08d13b2143f8a90e66c7e5b15fa6360a44323d581ad60ea148661

null--

graviton

code/external/upx/src/p_lx_elf.cpp

PackLinuxElf64::updateLoader

void PackLinuxElf64::updateLoader(OutputFile * ) { set_te64(&elfout.ehdr.e_entry, sz_pack2 + get_te64(&elfout.phdr[0].p_vaddr)); }

PackLinuxElf::PackLinuxElf(InputFile *f); PackLinuxElf::~PackLinuxElf(); void PackLinuxElf::pack3(OutputFile *fo, Filter &ft); void PackLinuxElf32::pack3(OutputFile *fo, Filter &ft); void PackLinuxElf64::pack3(OutputFile *fo, Filter &ft); void PackLinuxElf::defineSymbols(Filter const *); PackLinuxElf32::PackLinuxElf32(InputFile *f); PackLinuxElf32::~PackLinuxElf32(); PackLinuxElf64::PackLinuxElf64(InputFile *f); PackLinuxElf64::~PackLinuxElf64(); Linker* PackLinuxElf64amd::newLinker(); void PackLinuxElf32::patchLoader(); void PackLinuxElf64::patchLoader(); void PackLinuxElf32::ARM_updateLoader(OutputFile * /*fo*/); void PackLinuxElf32armLe::updateLoader(OutputFile *fo); void PackLinuxElf32armBe::updateLoader(OutputFile *fo); void PackLinuxElf32mipsel::updateLoader(OutputFile *fo); void PackLinuxElf32mipseb::updateLoader(OutputFile *fo); void PackLinuxElf32::updateLoader(OutputFile * /*fo*/); PackLinuxElf32ppc::PackLinuxElf32ppc(InputFile *f); PackLinuxElf32ppc::~PackLinuxElf32ppc(); Linker* PackLinuxElf32ppc::newLinker(); PackLinuxElf64amd::PackLinuxElf64amd(InputFile *f); PackLinuxElf64amd::~PackLinuxElf64amd(); void PackLinuxElf32x86::addStubEntrySections(Filter const *ft); void PackLinuxElf32x86::defineSymbols(Filter const *const ft); bool PackLinuxElf32::canPack(); void PackLinuxElf32::pack1(OutputFile *fo, Filter & /*ft*/); void PackLinuxElf32x86::pack1(OutputFile *fo, Filter &ft); void PackBSDElf32x86::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf32armLe::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf32armBe::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf32mipsel::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf32mipseb::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf32ppc::pack1(OutputFile *fo, Filter &ft); void PackLinuxElf64::pack1(OutputFile *fo, Filter & /*ft*/); void PackLinuxElf64amd::pack1(OutputFile *fo, Filter &ft); int PackLinuxElf32::pack2(OutputFile *fo, Filter &ft); int PackLinuxElf64::pack2(OutputFile *fo, Filter &ft); int PackLinuxElf32::ARM_is_QNX(void); void PackLinuxElf32::ARM_defineSymbols(Filter const * /*ft*/); void PackLinuxElf32armLe::defineSymbols(Filter const *ft); void PackLinuxElf32armBe::defineSymbols(Filter const *ft); void PackLinuxElf32mipseb::defineSymbols(Filter const * /*ft*/); void PackLinuxElf32mipsel::defineSymbols(Filter const * /*ft*/); void PackLinuxElf32::pack4(OutputFile *fo, Filter &ft); void PackLinuxElf64::pack4(OutputFile *fo, Filter &ft); void PackLinuxElf64::unpack(OutputFile *fo); PackLinuxElf32x86::PackLinuxElf32x86(InputFile *f); PackLinuxElf32x86::~PackLinuxElf32x86(); Linker* PackLinuxElf32x86::newLinker(); PackBSDElf32x86::PackBSDElf32x86(InputFile *f); PackBSDElf32x86::~PackBSDElf32x86(); PackFreeBSDElf32x86::PackFreeBSDElf32x86(InputFile *f); PackFreeBSDElf32x86::~PackFreeBSDElf32x86(); PackNetBSDElf32x86::PackNetBSDElf32x86(InputFile *f); PackNetBSDElf32x86::~PackNetBSDElf32x86(); PackOpenBSDElf32x86::PackOpenBSDElf32x86(InputFile *f); PackOpenBSDElf32x86::~PackOpenBSDElf32x86(); PackLinuxElf32armLe::PackLinuxElf32armLe(InputFile *f); PackLinuxElf32armLe::~PackLinuxElf32armLe(); PackLinuxElf32mipseb::PackLinuxElf32mipseb(InputFile *f); PackLinuxElf32mipseb::~PackLinuxElf32mipseb(); PackLinuxElf32mipsel::PackLinuxElf32mipsel(InputFile *f); PackLinuxElf32mipsel::~PackLinuxElf32mipsel(); Linker* PackLinuxElf32armLe::newLinker(); Linker* PackLinuxElf32mipseb::newLinker(); Linker* PackLinuxElf32mipsel::newLinker(); PackLinuxElf32armBe::PackLinuxElf32armBe(InputFile *f); PackLinuxElf32armBe::~PackLinuxElf32armBe(); Linker* PackLinuxElf32armBe::newLinker(); unsigned PackLinuxElf32::gnu_hash(char const *q); unsigned PackLinuxElf32::elf_hash(char const *p); Elf32_Sym const *PackLinuxElf32::elf_lookup(char const *name); void PackLinuxElf32::unpack(OutputFile *fo); void PackLinuxElf::unpack(OutputFile * /*fo*/);

0d41c06488de4f4168dcfcb5c01733f8634ce6e19f20001c9fbe142bc86b5836

KostasLifeboy

RyzomCore

ryzom/common/src/game_share/server_animation_module.cpp

CServerAnimationModule::stopAct

void CServerAnimationModule::stopAct(TSessionId sessionId) { nlinfo( "R2An: stopAct for sessionId %u", sessionId.asInt() ); if (!_Server->useNetwork()) { nlwarning("simulate stopAct"); return; } CAnimationSession* session = getSession(sessionId); if (!session) return; deactivateEasterEggsFromAct(sessionId, session->CurrentAct); session->CurrentAct = 0; uint32 aiInstance = session->AiInstance; CAiWrapper::getInstance().stopAct(session->SessionId, aiInstance); }

CRtNpc(TAIAlias alias, CObject* objectData, TAIAlias grpAlias, uint32 dmProperty); CRtGrp(TAIAlias alias, CObject* objectData, const std::string& fullName); bool activateEasterEgg(uint32 easterEggId, const std::string & grpControler); bool CRtAct::deactivateEasterEgg(uint32 easterEggId); R2::CRtGrp* CRtAct::getRtGrpByName(const std::string& name); void CRtAct::addUserTrigger(const CRtUserTrigger& userTrigger); void CBotControler::getBots(const NLMISC::CEntityId& eid, std::map<uint32, NLMISC::CEntityId>& bots); void CBotControler::getBots(uint32 charId, std::map<uint32, NLMISC::CEntityId>& bots); uint32 CBotControler::getBotsCount(uint32 charId); void CBotControler::removeChar(const NLMISC::CEntityId& eid); bool CBotControler::add(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId); bool CBotControler::remove(const NLMISC::CEntityId& eid, const NLMISC::CEntityId& creatureId); NLMISC::CEntityId CBotControler::getEntity(const NLMISC::CEntityId& eid, uint32 id); CAnimationSession(); void CAnimationSession::easterEggLooted(uint32 easterEggId, TSessionId /* scenarioId */); void CAnimationSession::setWeatherValue(uint16 weatherValue); void CAnimationSession::setSeason(uint8 season); void CAnimationSession::sendWeatherValueToChar(uint32 charId, uint16 weatherValue); void CAnimationSession::sendSeasonToChar(uint32 charId, uint8 season); void CAnimationSession::updateUserTriggerDescriptions(TUserTriggerDescriptions& userTriggerDescriptions); void CAnimationSession::updateActPositionDescriptions(TActPositionDescriptions& actPositionDescriptions); CAttributeToProperty(CObject* object, IPrimitive* prim); void setAttributeAsString(const std::string & attrName, const std::string& propName); void setAttributeAsStringWithPrefix(const std::string & attrName, const std::string& propName, const std::string& prefix); void setAttributeAsStringArrayWithPrefix(const std::string & attrName, const std::string& propName, const std::string& prefix); void setAttributeAsBool(const std::string & attrName, const std::string& propName); void setPrimPoint(); void CAttributeToProperty::setAttributeAsStringArray(const std::string & attrName, const std::string& propName); void CAttributeToProperty::setAiStateName(const std::string& prefix); void CAttributeToProperty::setPrimPath(); void CAttributeToProperty::setPrimZone(); void doOperation(); void doOperation(); CTaskStartAct(NLMISC::TTime t, CServerAnimationModule* animationModule, TSessionId sessionId, uint32 actId, bool mustTp); void doOperation(); CTaskScheduleStartSession( CServerAnimationModule* animationModule, const CAnimationMessageAnimationStart& msg); void doOperation(); void CServerAnimationModule::broadcastMessage(CAnimationSession* session, const NLNET::CMessage& msg); void CServerAnimationModule::scheduleStartAct(TSessionId sessionId, uint32 actId); void CServerAnimationModule::init(NLNET::IModuleSocket* gateway, CDynamicMapService* server); CServerAnimationModule::CServerAnimationModule(); CServerAnimationModule::~CServerAnimationModule(); IPrimitive* CServerAnimationModule::getAction(CObject* action, const std::string& prefix,TSessionId scenarioId); bool CServerAnimationModule::queueSession(CAnimationSession* session, bool /* runTest */); void CServerAnimationModule::startTest(TSessionId sessionId, CPersistentDataRecord& pdr); void CServerAnimationModule::startAct(TSessionId sessionId, uint32 actId); void CServerAnimationModule::setWeatherValue(TSessionId sessionId, uint16 weatherValue); void CServerAnimationModule::setSeasonValue(TSessionId sessionId, uint8 seasonValue); bool CServerAnimationModule::makeAnimationSession(CAnimationSession* animSession, bool /* runTest */); bool CServerAnimationModule::doMakeAnimationSession(CAnimationSession* animSession); bool CServerAnimationModule::getConnectedChars(TSessionId sessionId, std::vector<TCharId>& chars); bool CServerAnimationModule::stopTestImpl(TSessionId sessionId, uint32 & lastAct); bool CServerAnimationModule::stopTest(TSessionId sessionId, uint32 & lastAct); void CServerAnimationModule::onModuleUpdate(); void CServerAnimationModule::onModuleUp(NLNET::IModuleProxy *senderModuleProxy); void CServerAnimationModule::onModuleDown(NLNET::IModuleProxy *senderModuleProxy); bool CServerAnimationModule::getPosition(TSessionId sessionId, double& x, double& y, double& orient, uint8& season, uint32 actIndex); void CServerAnimationModule::getStartParams(NLNET::IModuleProxy * /* sender */, uint32 charId, TSessionId lastStoredSessionId); void CServerAnimationModule::askSetUserCharActPosition( NLNET::IModuleProxy * /* sender */, uint32 charId ); CAnimationSession* CServerAnimationModule::getSession(TSessionId sessionId); void CServerAnimationModule::connectAnimationModePlay(NLNET::IModuleProxy* proxy); TSessionId CServerAnimationModule::getSessionIdByCharId(TCharId charId); CAnimationSession* CServerAnimationModule::getSessionByCharId(TCharId charId); void CServerAnimationModule::addPioneer( TSessionId sessionId, TCharId charId); void CServerAnimationModule::onDssTarget( IModuleProxy *senderModuleProxy, const std::vector<std::string> & params); void CServerAnimationModule::stopIncarn(const NLMISC::CEntityId &eid, const NLMISC::CEntityId &creatureId); CRtNpc* CServerAnimationModule::getNpcByAlias(TSessionId sessionId, TAIAlias alias); void CServerAnimationModule::stopControlNpcs(TCharId charId); void CServerAnimationModule::askUpdateScenarioHeader(NLNET::IModuleProxy *clientProxyPtr); void CServerAnimationModule::askIncarnatingListUpdate(NLNET::IModuleProxy *clientProxyPtr); void CServerAnimationModule::askTalkingAsListUpdate(NLNET::IModuleProxy *clientProxyPtr); void CServerAnimationModule::updateIncarningList(TSessionId /* sessionId */, uint32 charId); void CServerAnimationModule::updateTalkingAsList(TSessionId /* sessionId */, uint32 charId); bool CServerAnimationModule::setIncarningPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid, TDataSetRow entityRowId, TAIAlias alias); bool CServerAnimationModule::setTalkingAsPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid, TDataSetRow entityRowId, TAIAlias alias); bool CServerAnimationModule::isIncarnedByPlayer(const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid); bool CServerAnimationModule::isTalkingAs(const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid); void CServerAnimationModule::removeTalkingAsPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid); void CServerAnimationModule::removeIncarningPlayer(TSessionId sessionId, const NLMISC::CEntityId& creatureId, const NLMISC::CEntityId& eid); void CServerAnimationModule::updateAnimationProperties(NLNET::IModuleProxy *senderModuleProxy, const NLMISC::CEntityId & eid, CRtNpc * rtNpc, CRtGrp* rtGrp); void CServerAnimationModule::characterReady(NLNET::IModuleProxy * /* sender */, const NLMISC::CEntityId &charEid); bool CServerAnimationModule::onProcessModuleMessage(IModuleProxy *senderModuleProxy, const CMessage &msgin); TSessionId CServerAnimationModule::getScenarioId(uint32 charId); void CServerAnimationModule::disconnectChar(TCharId charId); void CServerAnimationModule::scheduleStartSession(const CAnimationMessageAnimationStart &msg); void CServerAnimationModule::scheduleStartSessionImpl(const CAnimationMessageAnimationStart &msg); IPrimitive* CServerAnimationModule::getEvent(CObject* event,CInstanceMap& components, const std::string& prefix,TSessionId scenarioId); void CServerAnimationModule::requestLoadTable(CAnimationSession* session); void CServerAnimationModule::requestUnloadTable(TSessionId sessionId); void CServerAnimationModule::requestReleaseChannels(TSessionId sessionId); void CServerAnimationModule::onServiceUp(const std::string &serviceName, TServiceId /* serviceId */); void CServerAnimationModule::onServiceDown(const std::string &serviceName, TServiceId /* serviceId */); void CServerAnimationModule::askMissionItemsDescription(NLNET::IModuleProxy *senderModuleProxy); void CServerAnimationModule::deactivateEasterEggsFromAct(TSessionId scenarioId, uint32 actId); void CServerAnimationModule::deactivateEasterEgg(class NLNET::IModuleProxy * /* aisControl */, uint32 easterEggId, TSessionId scenarioId, uint32 actId); void CServerAnimationModule::activateEasterEgg(class NLNET::IModuleProxy * /* aisControl */, uint32 easterEggId, TSessionId scenarioId, uint32 actId ,const std::string & items, float x, float y, float z, float heading, const std::string& grpControler, const std::string& name, const std::string& look); void CServerAnimationModule::onEasterEggLooted(class NLNET::IModuleProxy * /* egs */, uint32 easterEggId, TSessionId scenarioId); void CServerAnimationModule::onUserTriggerTriggered(NLNET::IModuleProxy *senderModuleProxy, uint32 actId, uint32 triggerId); void CServerAnimationModule::triggerUserTrigger( TSessionId sessionId, uint32 actId, uint32 triggerId); void CServerAnimationModule::askActPositionDescriptions(NLNET::IModuleProxy *senderModuleProxy); void CServerAnimationModule::askUserTriggerDescriptions(NLNET::IModuleProxy *senderModuleProxy); void CServerAnimationModule::onBotDeathNotification(NLMISC::CEntityId& creatureId); void CServerAnimationModule::onBotDespawnNotification(NLMISC::CEntityId& creatureId); void CServerAnimationModule::onStopNpcControlNotification(NLMISC::CEntityId& creatureId); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadPdrFile); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, savePdrFile); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayPdr); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, clearPdr); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadPrimitiveFile); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, loadRtFile); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, startTest); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, stopTest); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayMissionItems); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, displayUserTriggers); NLMISC_CLASS_COMMAND_IMPL(CServerAnimationModule, triggerUserTrigger); IServerEditionModule* CServerAnimationModule::getEditionModule(); bool CServerAnimationModule::isSessionRunning(TSessionId sessionId); uint32 CServerAnimationModule::getCurrentAct(TSessionId sessionId); void CServerAnimationModule::dssMessage(NLNET::IModuleProxy * /* ais */, TSessionId sessionId, const std::string & msgType, const std::string& who, const std::string& msg); void CServerAnimationModule::setSessionStartParams(TSessionId sessionId, sint32 x, sint32 y, uint8 season); bool CServerAnimationModule::mustReloadPosition(TSessionId sessionId, TCharId charId); bool CServerAnimationModule::getHeaderInfo(TSessionId sessionId, TScenarioHeaderSerializer::TValueType& values); void CServerAnimationModule::teleportCharacter(NLNET::IModuleProxy * /* ais */, const NLMISC::CEntityId& eid, float x, float y, float z); void CServerAnimationModule::broadcastMsg(TSessionId sessionId, const NLNET::CMessage& msg); void CServerAnimationModule::setScenarioPoints(NLNET::IModuleProxy * /* ais */, TSessionId sessionId, float scenarioPoints); void CServerAnimationModule::startScenarioTiming(NLNET::IModuleProxy * /* ais */, TSessionId sessionId); void CServerAnimationModule::endScenarioTiming(NLNET::IModuleProxy * /* ais */, TSessionId sessionId); bool CServerAnimationModule::getScore(TSessionId sessionId, uint32 &score, NLMISC::TTime &timeTaken);

76ee83b429e58e1ebb23649362d20ad22659a7da882080c3f60fad596b7217be

pcolby

libqtaws

src/ses/deleteidentitypolicyresponse.cpp

DeleteIdentityPolicyResponse::request

const DeleteIdentityPolicyRequest * DeleteIdentityPolicyResponse::request() const { Q_D(const DeleteIdentityPolicyResponse); return static_cast<const DeleteIdentityPolicyRequest *>(d->request); }

void DeleteIdentityPolicyResponse::parseSuccess(QIODevice &response); void DeleteIdentityPolicyResponsePrivate::parseDeleteIdentityPolicyResponse(QXmlStreamReader &xml);

7cb8a7b9c0aa97cb89ef5d17eeb6b5b474b503386c8386a12131f02d4e1230f3

deepak899

libjingletestsuite

Common/mysqlplus.cpp

sql_result_c::fetch_row

sql_row_c sql_result_c::fetch_row() { MYSQL_ROW row = mysql_fetch_row( res ); return sql_row_c( row ); }

sql_connection_c::sql_connection_c(); sql_connection_c::sql_connection_c( char *__database, char *__host, char *__user, char *__password ); sql_connection_c::~sql_connection_c(); void sql_connection_c::connect( char *__database, char *__host, char *__user, char *__password ); OPENDB *sql_connection_c::grabdb(); void sql_connection_c::freedb( OPENDB *odb ); short sql_connection_c::errcode(); sql_query_c::sql_query_c(); sql_query_c::sql_query_c( sql_connection_c *__sql_connection ); sql_query_c::sql_query_c( sql_connection_c *__sql_connection, char *sql ); sql_query_c::~sql_query_c(); int sql_query_c::try_execute( char *sql ); int sql_query_c::execute( char *sql ); sql_result_c *sql_query_c::store(); void sql_query_c::free_result( sql_result_c *sql_result ); void sql_query_c::free_result(); __int64 sql_query_c::insert_id(); MYSQL_FIELD *sql_query_c::fetch_field(); char *sql_query_c::fetch_fieldname(); int sql_query_c::ping(); sql_var_c::sql_var_c(); sql_var_c::sql_var_c( int i ); sql_var_c::sql_var_c( double d ); sql_var_c::sql_var_c( char *s ); sql_var_c::sql_var_c( const char *s ); sql_var_c::~sql_var_c(); sql_var_c::operator int (); sql_var_c::operator double (); sql_var_c::operator char * (); sql_var_c::operator const char * (); void sql_var_c::operator = ( int i ); void sql_var_c::operator = ( double d ); void sql_var_c::operator = ( char *s ); void sql_var_c::operator = ( const char *s ); void sql_var_c::release(); sql_row_c::sql_row_c(); sql_row_c::sql_row_c( MYSQL_ROW __row ); void sql_row_c::allow_null( int allow ); sql_var_c sql_row_c::operator [] ( int idx ); sql_field_c::sql_field_c(); sql_field_c::sql_field_c( MYSQL_FIELD *__field ); char *sql_field_c::get_name(); char *sql_field_c::get_default_value(); enum_field_types sql_field_c::get_type(); unsigned int sql_field_c::get_max_length(); sql_result_c::sql_result_c(); sql_result_c::sql_result_c( sql_query_c *__query, MYSQL_RES *__res ); sql_result_c::~sql_result_c(); __int64 sql_result_c::n_rows(); unsigned int sql_result_c::n_fields(); sql_field_c sql_result_c::fetch_field( unsigned int field_idx );

d0b8f08573542673014b0d222405e8dd3acc6e968c94f3cfaa3a812e7341bdab

CarlosManuelRodr

wxChaos

SFML-1.6/src/SFML/Graphics/Drawable.cpp

Drawable::Move

void Drawable::Move(const Vector2f& Offset) { Move(Offset.x, Offset.y); }

Drawable::Drawable(const Vector2f& Position, const Vector2f& Scale, float Rotation, const Color& Col); Drawable::~Drawable(); void Drawable::SetPosition(float X, float Y); void Drawable::SetPosition(const Vector2f& Position); void Drawable::SetX(float X); void Drawable::SetY(float Y); void Drawable::SetScale(float ScaleX, float ScaleY); void Drawable::SetScale(const Vector2f& Scale); void Drawable::SetScaleX(float FactorX); void Drawable::SetScaleY(float FactorY); void Drawable::SetCenter(float CenterX, float CenterY); void Drawable::SetCenter(const Vector2f& Center); void Drawable::SetRotation(float Rotation); void Drawable::SetColor(const Color& Col); void Drawable::SetBlendMode(Blend::Mode Mode); const Vector2f& Drawable::GetPosition(); const Vector2f& Drawable::GetScale(); const Vector2f& Drawable::GetCenter(); float Drawable::GetRotation(); const Color& Drawable::GetColor(); Blend::Mode Drawable::GetBlendMode(); void Drawable::Move(float OffsetX, float OffsetY); void Drawable::Scale(float FactorX, float FactorY); void Drawable::Scale(const Vector2f& Factor); void Drawable::Rotate(float Angle); sf::Vector2f Drawable::TransformToLocal(const sf::Vector2f& Point); sf::Vector2f Drawable::TransformToGlobal(const sf::Vector2f& Point); const Matrix3& Drawable::GetMatrix(); const Matrix3& Drawable::GetInverseMatrix(); void Drawable::Draw(RenderTarget& Target);

5ec1d0b0cf0035c022d512582b2e04eb065ca05a25b29d403ddda8e543d441e6

Aman-Jain-14

customizedMesos

src/tests/containerizer/io_switchboard_tests.cpp

TEST_F

TEST_F(IOSwitchboardServerTest, ReceiveHeartbeat) { Try<std::array<int, 2>> stdoutPipe_ = os::pipe(); ASSERT_SOME(stdoutPipe_); const std::array<int, 2>& stdoutPipe = stdoutPipe_.get(); Try<int> nullFd = os::open(os::DEV_NULL, O_RDWR); ASSERT_SOME(nullFd); string socketPath = path::join(sandbox.get(), "mesos-io-switchboard"); Try<Owned<IOSwitchboardServer>> server = IOSwitchboardServer::create( false, nullFd.get(), stdoutPipe[0], nullFd.get(), nullFd.get(), nullFd.get(), socketPath, false); ASSERT_SOME(server); Future<Nothing> runServer = server.get()->run(); http::Pipe requestPipe; http::Pipe::Reader reader = requestPipe.reader(); http::Pipe::Writer writer = requestPipe.writer(); http::Request request; request.method = "POST"; request.type = http::Request::PIPE; request.reader = reader; request.url.domain = ""; request.url.path = "/"; request.keepAlive = true; request.headers["Accept"] = APPLICATION_JSON; request.headers["Content-Type"] = APPLICATION_RECORDIO; request.headers[MESSAGE_CONTENT_TYPE] = APPLICATION_JSON; Try<unix::Address> address = unix::Address::create(socketPath); ASSERT_SOME(address); Future<http::Connection> _connection = http::connect(address.get(), http::Scheme::HTTP); AWAIT_READY(_connection); http::Connection connection = _connection.get(); Future<http::Response> response = connection.send(request); ::recordio::Encoder<mesos::agent::Call> encoder(lambda::bind( serialize, ContentType::JSON, lambda::_1)); Call call; call.set_type(Call::ATTACH_CONTAINER_INPUT); Call::AttachContainerInput* attach = call.mutable_attach_container_input(); attach->set_type(Call::AttachContainerInput::CONTAINER_ID); attach->mutable_container_id()->set_value(UUID::random().toString()); writer.write(encoder.encode(call)); Duration heartbeat = Milliseconds(10); for (int i = 0; i < 5; i ++) { Call::AttachContainerInput* attach = call.mutable_attach_container_input(); attach->set_type(Call::AttachContainerInput::PROCESS_IO); ProcessIO* message = attach->mutable_process_io(); message->set_type(agent::ProcessIO::CONTROL); message->mutable_control()->set_type( agent::ProcessIO::Control::HEARTBEAT); message->mutable_control()->mutable_heartbeat() ->mutable_interval()->set_nanoseconds(heartbeat.ns()); writer.write(encoder.encode(call)); Clock::advance(heartbeat); } writer.close(); AWAIT_EXPECT_RESPONSE_STATUS_EQ(http::OK().status, response); AWAIT_READY(connection.disconnect()); AWAIT_READY(connection.disconnected()); os::close(stdoutPipe[1]); AWAIT_ASSERT_READY(runServer); os::close(stdoutPipe[0]); os::close(nullFd.get()); }

Future<tuple<string, string>> getProcessIOData(http::Pipe::Reader reader); TEST_F(IOSwitchboardServerTest, RedirectLog); TEST_F(IOSwitchboardServerTest, AttachOutput); TEST_F(IOSwitchboardServerTest, SendHeartbeat); TEST_F(IOSwitchboardServerTest, AttachInput); TEST_F(IOSwitchboardTest, ContainerAttach); TEST_F(IOSwitchboardTest, OutputRedirectionWithTTY); TEST_F(IOSwitchboardTest, KillSwitchboardContainerDestroyed); TEST_F(IOSwitchboardTest, DISABLED_RecoverThenKillSwitchboardContainerDestroyed); TEST_F(IOSwitchboardTest, ContainerAttachAfterSlaveRestart);

07f1c6ab3a075edbb3a935c6ec5cb395a48cfeb8f62718e5994ea9a0af611367

blois

AndroidSDKCloneMin

ndk/sources/android/crazy_linker/src/crazy_linker_thread_unittest.cpp

TEST

TEST(Thread, SetLinkerErrorString) { ThreadData* data = GetThreadData(); SetLinkerErrorString("Hello World"); EXPECT_STREQ("Hello World", data->GetError()); SetLinkerErrorString(NULL); EXPECT_STREQ("", data->GetError()); }

TEST(Thread, GetThreadData); TEST(Thread, GetErrorEmpty); TEST(Thread, SetError); TEST(Thread, SetErrorNull); TEST(Thread, GetError); TEST(Thread, SwapErrorBuffers); TEST(Thread, AppendErrorTwice); TEST(Thread, AppendErrorFull); TEST(Thread, AppendErrorNull); TEST(Thread, SetLinkerError);

325e017526f143ffa2c4b4c91f2e89fdb3e9a7a8cac7810eebd07d2487af1b92

AlphaMistral

PDP-Experiment

src/LogManager.cpp

Alert

r :: Alert(const char *str) { std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now(); std::time_t now_time = std::chrono::system_clock::to_time_t(now); std::cout << str << std::endl; logStream << std::ctime(&now_time) << str << std::endl; } void LogManag

LogManager(); r :: AppendToLog(std::string str); r :: AppendToLog(const char *str); r :: Alert(std::string str); r :: AlertWithExecutionTime(std::string str, bool restart); r :: AlertWithExecutionTime(const char *str, bool restart); r :: StartTiming(); ger :: GetExecutionTime(); omptf(const char *fmt, ...);

68287c4c6181fbf91ad08cbae77d4ede5bab42495ad06c6a9db4d7b1e27b813c

PopCap

GameIdea

Engine/Source/Runtime/Core/Private/Linux/LinuxApplication.cpp

FLinuxApplication::ProcessDeferredMessage

void FLinuxApplication::ProcessDeferredMessage( SDL_Event Event ) { SDL_HWindow NativeWindow = NULL; bool bWindowlessEvent = false; TSharedPtr< FLinuxWindow > CurrentEventWindow = FindEventWindow(&Event, bWindowlessEvent); if (CurrentEventWindow.IsValid()) { NativeWindow = CurrentEventWindow->GetHWnd(); } if (!NativeWindow && !bWindowlessEvent) { return; } switch(Event.type) { case SDL_KEYDOWN: { const SDL_KeyboardEvent &KeyEvent = Event.key; const SDL_Keycode KeySym = KeyEvent.keysym.sym; const uint32 CharCode = CharCodeFromSDLKeySym(KeySym); const bool bIsRepeated = KeyEvent.repeat != 0; MessageHandler->OnKeyDown(KeySym, CharCode, bIsRepeated); if (KeySym == SDLK_BACKSPACE) { MessageHandler->OnKeyChar('\b', bIsRepeated); } else if (KeySym == SDLK_RETURN) { MessageHandler->OnKeyChar('\r', bIsRepeated); } } break; case SDL_KEYUP: { const SDL_KeyboardEvent &KeyEvent = Event.key; const SDL_Keycode KeySym = KeyEvent.keysym.sym; const uint32 CharCode = CharCodeFromSDLKeySym(KeySym); const bool IsRepeat = KeyEvent.repeat != 0; MessageHandler->OnKeyUp( KeySym, CharCode, IsRepeat ); } break; case SDL_TEXTINPUT: { const bool bIsRepeated = false; const FString TextStr(UTF8_TO_TCHAR(Event.text.text)); for (auto TextIter = TextStr.CreateConstIterator(); TextIter; ++TextIter) { MessageHandler->OnKeyChar(*TextIter, bIsRepeated); } } break; case SDL_MOUSEMOTION: { SDL_MouseMotionEvent motionEvent = Event.motion; FLinuxCursor *LinuxCursor = (FLinuxCursor*)Cursor.Get(); LinuxCursor->InvalidateCaches(); if (LinuxCursor->IsHidden()) { if (bLockToCurrentMouseType == false) { int width, height; if(bIsMouseCursorLocked && CurrentClipWindow.IsValid()) { NativeWindow = CurrentClipWindow->GetHWnd(); } SDL_GetWindowSize(NativeWindow, &width, &height); if (motionEvent.x != (width / 2) || motionEvent.y != (height / 2)) { int xOffset, yOffset; SDL_GetWindowPosition(NativeWindow, &xOffset, &yOffset); LinuxCursor->SetPosition(width / 2 + xOffset, height / 2 + yOffset); } else { break; } } } else { int xOffset, yOffset; SDL_GetWindowPosition( NativeWindow, &xOffset, &yOffset ); int32 BorderSizeX, BorderSizeY; CurrentEventWindow->GetNativeBordersSize(BorderSizeX, BorderSizeY); LinuxCursor->SetCachedPosition(motionEvent.x + xOffset + BorderSizeX, motionEvent.y + yOffset + BorderSizeY); FVector2D CurrentPosition = LinuxCursor->GetPosition(); if( LinuxCursor->UpdateCursorClipping( CurrentPosition ) ) { LinuxCursor->SetPosition( CurrentPosition.X, CurrentPosition.Y ); } if( !CurrentEventWindow->GetDefinition().HasOSWindowBorder ) { if ( CurrentEventWindow->IsRegularWindow() ) { MessageHandler->GetWindowZoneForPoint( CurrentEventWindow.ToSharedRef(), CurrentPosition.X - xOffset, CurrentPosition.Y - yOffset ); MessageHandler->OnCursorSet(); } } } if(bUsingHighPrecisionMouseInput) { const int kTooFarAway = 100; const int kTooFarAwaySquare = kTooFarAway * kTooFarAway; if (motionEvent.xrel * motionEvent.xrel + motionEvent.yrel * motionEvent.yrel > kTooFarAwaySquare) { UE_LOG(LogLinuxWindowEvent, Warning, TEXT("Suppressing too large relative mouse movement due to an apparent bug (%d, %d is larger than treshold %d)"), motionEvent.xrel, motionEvent.yrel, kTooFarAway ); } else { MessageHandler->OnRawMouseMove(motionEvent.xrel, motionEvent.yrel); } } else { MessageHandler->OnMouseMove(); } } break; case SDL_MOUSEBUTTONDOWN: case SDL_MOUSEBUTTONUP: { SDL_MouseButtonEvent buttonEvent = Event.button; EMouseButtons::Type button; switch(buttonEvent.button) { case SDL_BUTTON_LEFT: button = EMouseButtons::Left; break; case SDL_BUTTON_MIDDLE: button = EMouseButtons::Middle; break; case SDL_BUTTON_RIGHT: button = EMouseButtons::Right; break; case SDL_BUTTON_X1: button = EMouseButtons::Thumb01; break; case SDL_BUTTON_X2: button = EMouseButtons::Thumb02; break; default: button = EMouseButtons::Invalid; break; } if (buttonEvent.type == SDL_MOUSEBUTTONUP) { MessageHandler->OnMouseUp(button); if (buttonEvent.button == SDL_BUTTON_LEFT) { bLockToCurrentMouseType = false; bIsDragWindowButtonPressed = false; } } else { if (!bActivateApp) { ActivateApplication(); } if (buttonEvent.button == SDL_BUTTON_LEFT) { if (((FLinuxCursor*)Cursor.Get())->GetType() != EMouseCursor::None) { bLockToCurrentMouseType = true; } bIsDragWindowButtonPressed = true; } if (buttonEvent.clicks == 2) { MessageHandler->OnMouseDoubleClick(CurrentEventWindow, button); } else { if (CurrentlyActiveWindow != CurrentEventWindow) { ActivateWindow(CurrentEventWindow); if(NotificationWindows.Num() > 0) { RaiseNotificationWindows(CurrentEventWindow); } } if(CurrentFocusWindow != CurrentEventWindow) { SDL_RaiseWindow(CurrentEventWindow->GetHWnd()); if(CurrentEventWindow->IsPopupMenuWindow()) { SDL_SetKeyboardGrab(CurrentEventWindow->GetHWnd(), SDL_TRUE); } else { SDL_SetWindowInputFocus(CurrentEventWindow->GetHWnd()); } } MessageHandler->OnMouseDown(CurrentEventWindow, button); } } } break; case SDL_MOUSEWHEEL: { SDL_MouseWheelEvent *WheelEvent = &Event.wheel; float Amount = WheelEvent->y * fMouseWheelScrollAccel; MessageHandler->OnMouseWheel(Amount); } break; case SDL_CONTROLLERAXISMOTION: { SDL_ControllerAxisEvent caxisEvent = Event.caxis; FGamepadKeyNames::Type Axis = FGamepadKeyNames::Invalid; float AxisValue = ShortToNormalFloat(caxisEvent.value); if (!ControllerStates.Contains(caxisEvent.which)) { break; } SDLControllerState &ControllerState = ControllerStates[caxisEvent.which]; switch (caxisEvent.axis) { case SDL_CONTROLLER_AXIS_LEFTX: Axis = FGamepadKeyNames::LeftAnalogX; if(caxisEvent.value > GAMECONTROLLER_LEFT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[0]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::LeftStickRight, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[0] = true; } } else if(ControllerState.AnalogOverThreshold[0]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::LeftStickRight, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[0] = false; } if(caxisEvent.value < -GAMECONTROLLER_LEFT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[1]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::LeftStickLeft, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[1] = true; } } else if(ControllerState.AnalogOverThreshold[1]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::LeftStickLeft, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[1] = false; } break; case SDL_CONTROLLER_AXIS_LEFTY: Axis = FGamepadKeyNames::LeftAnalogY; AxisValue *= -1; if(caxisEvent.value > GAMECONTROLLER_LEFT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[2]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::LeftStickDown, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[2] = true; } } else if(ControllerState.AnalogOverThreshold[2]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::LeftStickDown, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[2] = false; } if(caxisEvent.value < -GAMECONTROLLER_LEFT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[3]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::LeftStickUp, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[3] = true; } } else if(ControllerState.AnalogOverThreshold[3]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::LeftStickUp, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[3] = false; } break; case SDL_CONTROLLER_AXIS_RIGHTX: Axis = FGamepadKeyNames::RightAnalogX; if(caxisEvent.value > GAMECONTROLLER_RIGHT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[4]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::RightStickRight, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[4] = true; } } else if(ControllerState.AnalogOverThreshold[4]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::RightStickRight, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[4] = false; } if(caxisEvent.value < -GAMECONTROLLER_RIGHT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[5]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::RightStickLeft, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[5] = true; } } else if(ControllerState.AnalogOverThreshold[5]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::RightStickLeft, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[5] = false; } break; case SDL_CONTROLLER_AXIS_RIGHTY: Axis = FGamepadKeyNames::RightAnalogY; AxisValue *= -1; if(caxisEvent.value > GAMECONTROLLER_RIGHT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[6]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::RightStickDown, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[6] = true; } } else if(ControllerState.AnalogOverThreshold[6]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::RightStickDown, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[6] = false; } if(caxisEvent.value < -GAMECONTROLLER_RIGHT_THUMB_DEADZONE) { if(!ControllerState.AnalogOverThreshold[7]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::RightStickUp, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[7] = true; } } else if(ControllerState.AnalogOverThreshold[7]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::RightStickUp, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[7] = false; } break; case SDL_CONTROLLER_AXIS_TRIGGERLEFT: Axis = FGamepadKeyNames::LeftTriggerAnalog; if(caxisEvent.value > GAMECONTROLLER_TRIGGER_THRESHOLD) { if(!ControllerState.AnalogOverThreshold[8]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::LeftTriggerThreshold, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[8] = true; } } else if(ControllerState.AnalogOverThreshold[8]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::LeftTriggerThreshold, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[8] = false; } break; case SDL_CONTROLLER_AXIS_TRIGGERRIGHT: Axis = FGamepadKeyNames::RightTriggerAnalog; if(caxisEvent.value > GAMECONTROLLER_TRIGGER_THRESHOLD) { if(!ControllerState.AnalogOverThreshold[9]) { MessageHandler->OnControllerButtonPressed(FGamepadKeyNames::RightTriggerThreshold, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[9] = true; } } else if(ControllerState.AnalogOverThreshold[9]) { MessageHandler->OnControllerButtonReleased(FGamepadKeyNames::RightTriggerThreshold, ControllerState.ControllerIndex, false); ControllerState.AnalogOverThreshold[9] = false; } break; default: break; } if (Axis != FGamepadKeyNames::Invalid) { float & ExistingAxisEventValue = ControllerState.AxisEvents.FindOrAdd(Axis); ExistingAxisEventValue = AxisValue; } } break; case SDL_CONTROLLERBUTTONDOWN: case SDL_CONTROLLERBUTTONUP: { SDL_ControllerButtonEvent cbuttonEvent = Event.cbutton; FGamepadKeyNames::Type Button = FGamepadKeyNames::Invalid; if (!ControllerStates.Contains(cbuttonEvent.which)) { break; } switch (cbuttonEvent.button) { case SDL_CONTROLLER_BUTTON_A: Button = FGamepadKeyNames::FaceButtonBottom; break; case SDL_CONTROLLER_BUTTON_B: Button = FGamepadKeyNames::FaceButtonRight; break; case SDL_CONTROLLER_BUTTON_X: Button = FGamepadKeyNames::FaceButtonLeft; break; case SDL_CONTROLLER_BUTTON_Y: Button = FGamepadKeyNames::FaceButtonTop; break; case SDL_CONTROLLER_BUTTON_BACK: Button = FGamepadKeyNames::SpecialLeft; break; case SDL_CONTROLLER_BUTTON_START: Button = FGamepadKeyNames::SpecialRight; break; case SDL_CONTROLLER_BUTTON_LEFTSTICK: Button = FGamepadKeyNames::LeftStickDown; break; case SDL_CONTROLLER_BUTTON_RIGHTSTICK: Button = FGamepadKeyNames::RightStickDown; break; case SDL_CONTROLLER_BUTTON_LEFTSHOULDER: Button = FGamepadKeyNames::LeftShoulder; break; case SDL_CONTROLLER_BUTTON_RIGHTSHOULDER: Button = FGamepadKeyNames::RightShoulder; break; case SDL_CONTROLLER_BUTTON_DPAD_UP: Button = FGamepadKeyNames::DPadUp; break; case SDL_CONTROLLER_BUTTON_DPAD_DOWN: Button = FGamepadKeyNames::DPadDown; break; case SDL_CONTROLLER_BUTTON_DPAD_LEFT: Button = FGamepadKeyNames::DPadLeft; break; case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: Button = FGamepadKeyNames::DPadRight; break; default: break; } if (Button != FGamepadKeyNames::Invalid) { if(cbuttonEvent.type == SDL_CONTROLLERBUTTONDOWN) { MessageHandler->OnControllerButtonPressed(Button, ControllerStates[cbuttonEvent.which].ControllerIndex, false); } else { MessageHandler->OnControllerButtonReleased(Button, ControllerStates[cbuttonEvent.which].ControllerIndex, false); } } } break; case SDL_WINDOWEVENT: { SDL_WindowEvent windowEvent = Event.window; switch (windowEvent.event) { case SDL_WINDOWEVENT_SIZE_CHANGED: { int NewWidth = windowEvent.data1; int NewHeight = windowEvent.data2; MessageHandler->OnSizeChanged( CurrentEventWindow.ToSharedRef(), NewWidth, NewHeight, false ); } break; case SDL_WINDOWEVENT_RESIZED: { int NewWidth = windowEvent.data1; int NewHeight = windowEvent.data2; MessageHandler->OnSizeChanged( CurrentEventWindow.ToSharedRef(), NewWidth, NewHeight, false ); MessageHandler->OnResizingWindow( CurrentEventWindow.ToSharedRef() ); } break; case SDL_WINDOWEVENT_CLOSE: { MessageHandler->OnWindowClose( CurrentEventWindow.ToSharedRef() ); } break; case SDL_WINDOWEVENT_SHOWN: { CurrentEventWindow->CacheNativeProperties(); if (!bActivateApp && !CurrentEventWindow->IsTooltipWindow()) { ActivateApplication(); } if (CurrentlyActiveWindow != CurrentEventWindow && CurrentEventWindow->IsActivateWhenFirstShown()) { ActivateWindow(CurrentEventWindow); } if (CurrentEventWindow->IsFocusWhenFirstShown()) { if (CurrentEventWindow->IsPopupMenuWindow()) { SDL_SetKeyboardGrab(CurrentEventWindow->GetHWnd(), SDL_TRUE); } else { SDL_SetWindowInputFocus(CurrentEventWindow->GetHWnd()); } } int Width, Height; SDL_GetWindowSize(NativeWindow, &Width, &Height); MessageHandler->OnSizeChanged( CurrentEventWindow.ToSharedRef(), Width, Height, false ); } break; case SDL_WINDOWEVENT_MOVED: { int32 ClientScreenX = windowEvent.data1; int32 ClientScreenY = windowEvent.data2; int32 BorderSizeX, BorderSizeY; CurrentEventWindow->GetNativeBordersSize(BorderSizeX, BorderSizeY); ClientScreenX += BorderSizeX; ClientScreenY += BorderSizeY; MessageHandler->OnMovedWindow(CurrentEventWindow.ToSharedRef(), ClientScreenX, ClientScreenY); } break; case SDL_WINDOWEVENT_MAXIMIZED: { MessageHandler->OnWindowAction(CurrentEventWindow.ToSharedRef(), EWindowAction::Maximize); UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("Window: '%d' got maximized"), CurrentEventWindow->GetID()); } break; case SDL_WINDOWEVENT_RESTORED: { MessageHandler->OnWindowAction(CurrentEventWindow.ToSharedRef(), EWindowAction::Restore); UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("Window: '%d' got restored"), CurrentEventWindow->GetID()); } break; case SDL_WINDOWEVENT_ENTER: { if (CurrentEventWindow.IsValid()) { MessageHandler->OnCursorSet(); bInsideOwnWindow = true; UE_LOG(LogLinuxWindow, Verbose, TEXT("Entered one of application windows")); } } break; case SDL_WINDOWEVENT_LEAVE: { if (CurrentEventWindow.IsValid()) { if (GetCapture() != nullptr) { UpdateMouseCaptureWindow((SDL_HWindow)GetCapture()); } bInsideOwnWindow = false; UE_LOG(LogLinuxWindow, Verbose, TEXT("Left an application window we were hovering above.")); } } break; case SDL_WINDOWEVENT_HIT_TEST: { if (!bActivateApp && !CurrentEventWindow->IsTooltipWindow()) { ActivateApplication(); } if (CurrentlyActiveWindow != CurrentEventWindow) { ActivateWindow(CurrentEventWindow); } if (CurrentEventWindow.IsValid()) { SDL_SetWindowInputFocus(CurrentEventWindow->GetHWnd()); } if (NotificationWindows.Num() > 0) { RaiseNotificationWindows(CurrentEventWindow); } } break; case SDL_WINDOWEVENT_TAKE_FOCUS: { if (!bActivateApp) { ActivateApplication(); } if(CurrentFocusWindow != CurrentEventWindow) { SDL_SetWindowInputFocus(CurrentEventWindow->GetHWnd()); } } break; case SDL_WINDOWEVENT_FOCUS_GAINED: { UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("WM_SETFOCUS : %d"), CurrentEventWindow->GetID()); CurrentFocusWindow = CurrentEventWindow; } break; case SDL_WINDOWEVENT_FOCUS_LOST: { UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("WM_KILLFOCUS : %d"), CurrentEventWindow->GetID()); if(CurrentFocusWindow == CurrentEventWindow) { if(bActivateApp) { SDL_Event event; event.type = SDL_USEREVENT; event.user.code = CheckForDeactivation; SDL_PushEvent(&event); } } CurrentFocusWindow = nullptr; } break; case SDL_WINDOWEVENT_HIDDEN: case SDL_WINDOWEVENT_EXPOSED: case SDL_WINDOWEVENT_MINIMIZED: default: break; } } break; case SDL_DROPBEGIN: { check(DragAndDropQueue.Num() == 0); check(DragAndDropTextQueue.Num() == 0); } break; case SDL_DROPFILE: { FString tmp = StringUtility::UnescapeURI(UTF8_TO_TCHAR(Event.drop.file)); DragAndDropQueue.Add(tmp); SDL_free(Event.drop.file); UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("File dropped: %s"), *tmp); } break; case SDL_DROPTEXT: { FString tmp = UTF8_TO_TCHAR(Event.drop.file); DragAndDropTextQueue.Add(tmp); SDL_free(Event.drop.file); UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("Text dropped: %s"), *tmp); } break; case SDL_DROPCOMPLETE: { if (DragAndDropQueue.Num() > 0) { MessageHandler->OnDragEnterFiles(CurrentEventWindow.ToSharedRef(), DragAndDropQueue); MessageHandler->OnDragDrop(CurrentEventWindow.ToSharedRef()); DragAndDropQueue.Empty(); } if (DragAndDropTextQueue.Num() > 0) { for (const auto & Text : DragAndDropTextQueue) { MessageHandler->OnDragEnterText(CurrentEventWindow.ToSharedRef(), Text); MessageHandler->OnDragDrop(CurrentEventWindow.ToSharedRef()); } DragAndDropTextQueue.Empty(); } UE_LOG(LogLinuxWindowEvent, Verbose, TEXT("DragAndDrop finished for Window : %d"), CurrentEventWindow->GetID()); } break; case SDL_USEREVENT: { if(Event.user.code == CheckForDeactivation) { if (!CurrentFocusWindow.IsValid() && !bIsDragWindowButtonPressed) { DeactivateApplication(); } } } break; } }

float ShortToNormalFloat(short AxisVal); FLinuxApplication* FLinuxApplication::CreateLinuxApplication(); FLinuxApplication::FLinuxApplication(); FLinuxApplication::~FLinuxApplication(); void FLinuxApplication::DestroyApplication(); TSharedRef< FGenericWindow > FLinuxApplication::MakeWindow(); void FLinuxApplication::SetMessageHandler( const TSharedRef< FGenericApplicationMessageHandler >& InMessageHandler ); TSharedPtr< FLinuxWindow > FindWindowBySDLWindow(const TArray< TSharedRef< FLinuxWindow > >& WindowsToSearch, SDL_HWindow const WindowHandle); TSharedPtr< FLinuxWindow > FLinuxApplication::FindWindowBySDLWindow(SDL_Window *win); void FLinuxApplication::PumpMessages( const float TimeDelta ); bool FLinuxApplication::IsCursorDirectlyOverSlateWindow(); void FLinuxApplication::AddPendingEvent( SDL_Event SDLEvent ); bool FLinuxApplication::GeneratesKeyCharMessage(const SDL_KeyboardEvent & KeyDownEvent); static inline uint32 CharCodeFromSDLKeySym(const SDL_Keycode KeySym); EWindowZone::Type FLinuxApplication::WindowHitTest(const TSharedPtr< FLinuxWindow > &Window, int x, int y); void FLinuxApplication::ProcessDeferredEvents( const float TimeDelta ); void FLinuxApplication::PollGameDeviceState( const float TimeDelta ); TCHAR FLinuxApplication::ConvertChar( SDL_Keysym Keysym ); TSharedPtr< FLinuxWindow > FLinuxApplication::FindEventWindow(SDL_Event* Event, bool& bOutWindowlessEvent); void FLinuxApplication::RemoveEventWindow(SDL_HWindow HWnd); FModifierKeysState FLinuxApplication::GetModifierKeys(); void FLinuxApplication::SetCapture( const TSharedPtr< FGenericWindow >& InWindow ); void* FLinuxApplication::GetCapture( void ); void FLinuxApplication::UpdateMouseCaptureWindow(SDL_HWindow TargetWindow); void FLinuxApplication::SetHighPrecisionMouseMode( const bool Enable, const TSharedPtr< FGenericWindow >& InWindow ); void FLinuxApplication::RefreshDisplayCache(); FPlatformRect FLinuxApplication::GetWorkArea( const FPlatformRect& CurrentWindow ); void FLinuxApplication::OnMouseCursorLock( bool bLockEnabled ); bool FLinuxApplication::TryCalculatePopupWindowPosition( const FPlatformRect& InAnchor, const FVector2D& InSize, const EPopUpOrientation::Type Orientation, /*OUT*/ FVector2D* const CalculatedPopUpPosition ); void FDisplayMetrics::GetDisplayMetrics(FDisplayMetrics& OutDisplayMetrics); void FLinuxApplication::RemoveNotificationWindow(SDL_HWindow HWnd); void FLinuxApplication::RaiseNotificationWindows(const TSharedPtr< FLinuxWindow >& ParentWindow); void FLinuxApplication::RemoveRevertFocusWindow(SDL_HWindow HWnd); void FLinuxApplication::ActivateApplication(); void FLinuxApplication::DeactivateApplication(); void FLinuxApplication::ActivateWindow(const TSharedPtr< FLinuxWindow >& Window); void FLinuxApplication::ActivateRootWindow(const TSharedPtr< FLinuxWindow >& Window); TSharedPtr< FLinuxWindow > FLinuxApplication::GetRootWindow(const TSharedPtr< FLinuxWindow >& Window); bool FLinuxApplication::Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar); bool FLinuxApplication::HandleCursorCommand(const TCHAR* Cmd, FOutputDevice& Ar); bool FLinuxApplication::HandleWindowCommand(const TCHAR* Cmd, FOutputDevice& Ar);

64fac203a5fa3ea670bf3f6772e48eb05c323d5bc22b0eec61c25f28d3ff17bf

PlayFab

PlayFab-Samples

Samples/Win32/ThunderRumble/Kits/PeerMeshForSamples/PeerMeshForSamples/PeerToPeerNetworkManager.cpp

PeerToPeerNetworkManager::MarkAcknowledgedSegments

void PeerToPeerNetworkManager::MarkAcknowledgedSegments() { for (auto segment : _retries) { auto peer = _peers.find(segment->Destination); if (peer != _peers.end()) { auto conn = (*peer).second; if (conn != nullptr && segment->Sequence <= conn->OldestUnacknowledged) { DEBUGLOG(L"Peer %u ack'd sequence %u\n", conn->Id, segment->Sequence); segment->Acknowledged = true; } } } }

PeerToPeerNetworkManager::~PeerToPeerNetworkManager();

6d878c01a079c611b5ff8236784ced75778be54e2011efd05db4e76444918aa1

domin1101

ANNHelper

src/LightBulbApp/TrainingPlans/Preferences/PreferenceGroup.cpp

referenceGroup::PreferenceGroup

referenceGroup::PreferenceGroup(const std::string& name_) { name = name_; }

referenceGroup::PreferenceGroup(const PreferenceGroup& other); referenceGroup::PreferenceGroup(PreferenceGroup&& other); referenceGroup& PreferenceGroup::operator=(PreferenceGroup other); oid swap(PreferenceGroup& lhs, PreferenceGroup& rhs); onst std::string& PreferenceGroup::getName(); td::string PreferenceGroup::toString(std::string offset); oid PreferenceGroup::setName(std::string newName); oid PreferenceGroup::addPreference(AbstractPreferenceElement* preferenceElement); bstractCloneable* PreferenceGroup::clone(); onst AbstractPreference& PreferenceGroup::getPreference(const std::string& preferenceName); referenceGroup& PreferenceGroup::getPreferenceGroup(const std::string& preferenceGroupName); ouble PreferenceGroup::getDoublePreference(const std::string& preferenceName); nt PreferenceGroup::getIntegerPreference(const std::string& preferenceName); ool PreferenceGroup::getBooleanPreference(const std::string& preferenceName); td::string PreferenceGroup::getChoicePreference(const std::string& preferenceName); onst std::vector<std::unique_ptr<AbstractPreferenceElement>>& PreferenceGroup::getPreferenceElements();

563ea7565f9459b2c8c6dc5e048641007c14b88937b4337d476a85c7e7b8cbb3

brianbbsu

program

code archive/AtCoder/AGC 029E.cpp

main

int main() { IOS(); ll n; cin>>n; REP(i,n-1) { ll a,b; cin>>a>>b; if(a > b)swap(a,b); v[a].pb(b); v[b].pb(a); if(a != 1)e.pb(ii(a,b)); } REP1(i,n)g[i] = i, sz[i] = 1; sz[1] = 0; REP1(i,n)sort(ALL(v[i])); ok[1] = 1; REP1(k, n) { for(ii p:e)if(p.Y <= k)mg(p.X, p.Y); for(ll x:v[1])ok[f(x)]=1; for(int i = 2;i <= n;i ++)if(!ans[i]) { debug(k, i); if(i <= k && ok[f(i)])ans[i] = sz[f(i)]; else if(i > k) { ll tmp = 0, fg = 0; for(ll x:v[i]) { if(x > k)break; if(ok[f(x)])fg = 1; tmp += sz[f(x)]; } if(fg)ans[i] = tmp + 1; } } for(ll x:v[1])ok[f(x)]=0; } for(int i = 2;i <= n;i ++)cout<<ans[i]<<" "; }

ostream& _OUTC(ostream &_s,It _ita,It _itb); void mg(ll a,ll b);

b6db862d46f23e4cf46849a355a9d2197da9d6d71f38770a59372f6c0bdf32be

mekolat

ManaPlus

src/gui/widgets/popuplist.cpp

PopupList::widgetResized

void PopupList::widgetResized(const Event &event) { Popup::widgetResized(event); adjustSize(); }

void PopupList::postInit(); PopupList::~PopupList(); void PopupList::show(int x, int y); void PopupList::setSelected(const int selected); int PopupList::getSelected(); void PopupList::setListModel(ListModel *const model); void PopupList::adjustSize(); void PopupList::mousePressed(MouseEvent& event); void PopupList::mouseReleased(MouseEvent& event); void PopupList::focusGained(const Event& event); void PopupList::focusLost(const Event& event A_UNUSED);

1eefba9de548ba1ff8c1f04516dff73690c74eb23281e2d1c311750e0959fb91

alibaba

tair

src/dataserver/duplicate_manager.cpp

duplicate_sender_manager::~duplicate_sender_manager

duplicate_sender_manager::~duplicate_sender_manager() { this->stop(); this->wait(); map<uint32_t, bucket_waiting_queue>::iterator it = packets_mgr.begin(); for (; it != packets_mgr.end(); ++it) { int size = it->second.size(); if (size) log_error("data not be duplicated:bucket id =%d num = %d", it->first, size); } if (eio.started) { easy_io_stop(&eio); easy_io_wait(&eio); easy_io_destroy(&eio); } }

bucket_waiting_queue::bucket_waiting_queue(duplicate_sender_manager *psm, uint32_t bucket_number); void bucket_waiting_queue::push(request_duplicate_packet &p_packet, uint64_t server_id); void bucket_waiting_queue::pop(uint64_t server_id); bool bucket_waiting_queue::pop(uint32_t packet_id, uint64_t server_id); size_t bucket_waiting_queue::size(); bool bucket_waiting_queue::send(int64_t now); void bucket_waiting_queue::do_server_table_change(const set<uint64_t> &available_server_tmp); bucket_waiting_queue::~bucket_waiting_queue(); duplicate_sender_manager::duplicate_sender_manager(table_manager *table_mgr); void duplicate_sender_manager::do_hash_table_changed(); bool duplicate_sender_manager::is_bucket_available(uint32_t bucket_number); bool duplicate_sender_manager::has_bucket_duplicate_done(int bucketNumber); void duplicate_sender_manager::do_duplicate_response(uint32_t bucket_id, uint64_t d_serverId, uint32_t packet_id); void duplicate_sender_manager::run(tbsys::CThread *thread, void *arg); int duplicate_sender_manager::packet_handler(easy_request_t *r);

870e258c162106e33a2661100bdc8df5f0ae8572b32e07be25454ab9cd275120

pfchrono

rs-ascent

src/ascent-world/Unit.cpp

Unit::AbsorbDamage

uint32 Unit::AbsorbDamage( uint32 School, uint32* dmg ) { if( dmg == NULL ) return 0; if( School > 6 ) return 0; SchoolAbsorb::iterator i, j; uint32 abs = 0; for( i = Absorbs[School].begin(); i != Absorbs[School].end(); ) { if( (int32)(*dmg) >= (*i)->amt) { (*dmg) -= (*i)->amt; abs += (*i)->amt; j = i++; if( i != Absorbs[School].end() ) { while( (*i)->spellid == (*j)->spellid ) { ++i; if( i == Absorbs[School].end() ) break; } } this->RemoveAura((*j)->spellid); if(!*dmg) break; } else { abs += *dmg; (*i)->amt -= *dmg; *dmg=0; break; } } return abs; }

Unit::Unit(); Unit::~Unit(); void Unit::Update( uint32 p_time ); bool Unit::canReachWithAttack(Unit *pVictim); void Unit::GiveGroupXP(Unit *pVictim, Player *PlayerInGroup); uint32 Unit::HandleProc( uint32 flag, Unit* victim, SpellEntry* CastingSpell, uint32 dmg, uint32 abs , uint32 weapon_damage_type); void Unit::HandleProcDmgShield(uint32 flag, Unit* attacker); bool Unit::isCasting(); bool Unit::IsInInstance(); void Unit::RegenerateHealth(); void Unit::RegeneratePower(bool isinterrupted); void Unit::CalculateResistanceReduction(Unit *pVictim,dealdamage * dmg, SpellEntry* ability); uint32 Unit::GetSpellDidHitResult( Unit* pVictim, uint32 weapon_damage_type, SpellEntry* ability ); void Unit::Strike( Unit* pVictim, uint32 weapon_damage_type, SpellEntry* ability, int32 add_damage, int32 pct_dmg_mod, uint32 exclusive_damage, bool disable_proc, bool skip_hit_check ); void Unit::smsg_AttackStop(Unit* pVictim); void Unit::smsg_AttackStop(uint64 victimGuid); void Unit::smsg_AttackStart(Unit* pVictim); void Unit::AddAura(Aura *aur); bool Unit::RemoveAura(Aura *aur); bool Unit::RemoveAura(uint32 spellId); bool Unit::RemoveAuras(uint32 * SpellIds); bool Unit::RemoveAurasByHeal(); bool Unit::RemoveAura(uint32 spellId, uint64 guid); bool Unit::RemoveAuraByNameHash(uint32 namehash); bool Unit::RemoveAuraPosByNameHash(uint32 namehash); bool Unit::RemoveAuraNegByNameHash(uint32 namehash); bool Unit::RemoveAllAuras(uint32 spellId, uint64 guid); bool Unit::RemoveAllAuraByNameHash(uint32 namehash); uint32 Unit::RemoveAllPosAuraByNameHash(uint32 namehash); uint32 Unit::RemoveAllNegAuraByNameHash(uint32 namehash); void Unit::RemoveNegativeAuras(); void Unit::RemoveAllAuras(); void Unit::RemoveAllAuraType(uint32 auratype); void Unit::RemoveAllAuraFromSelfType2(uint32 auratype, uint32 butskip_hash); bool Unit::SetAurDuration(uint32 spellId,Unit* caster,uint32 duration); bool Unit::SetAurDuration(uint32 spellId,uint32 duration); Aura* Unit::FindAuraPosByNameHash(uint32 namehash); Aura* Unit::FindAura(uint32 spellId); Aura* Unit::FindAura(uint32 spellId, uint64 guid); void Unit::_UpdateSpells( uint32 time ); void Unit::castSpell( Spell * pSpell ); int32 Unit::GetSpellDmgBonus(Unit *pVictim, SpellEntry *spellInfo,int32 base_dmg, bool isdot); void Unit::InterruptSpell(); void Unit::DeMorph(); void Unit::Emote(EmoteType emote); void Unit::SendChatMessageToPlayer(uint8 type, uint32 lang, const char *msg, Player *plr); void Unit::SendChatMessageAlternateEntry(uint32 entry, uint8 type, uint32 lang, const char * msg); void Unit::SendChatMessage(uint8 type, uint32 lang, const char *msg); void Unit::WipeHateList(); void Unit::ClearHateList(); void Unit::WipeTargetList(); void Unit::AddInRangeObject(Object* pObj); void Unit::OnRemoveInRangeObject(Object* pObj); void Unit::ClearInRangeSet(); void Unit::EventAddEmote(EmoteType emote, uint32 time); void Unit::EmoteExpire(); uint32 Unit::GetResistance(uint32 type); void Unit::MoveToWaypoint(uint32 wp_id); int32 Unit::GetDamageDoneMod(uint32 school); float Unit::GetDamageDonePctMod(uint32 school); void Unit::CalcDamage(); uint32 Unit::ManaShieldAbsorb(uint32 dmg); bool Unit::setDetectRangeMod(uint64 guid, int32 amount); void Unit::unsetDetectRangeMod(uint64 guid); int32 Unit::getDetectRangeMod(uint64 guid); void Unit::SetStandState(uint8 standstate); void Unit::RemoveAurasByInterruptFlag(uint32 flag); bool Unit::HasAuraVisual(uint32 visualid); bool Unit::HasAura(uint32 spellid); void Unit::DropAurasOnDeath(); void Unit::UpdateSpeed(); bool Unit::HasActiveAura(uint32 spellid); bool Unit::HasActiveAura(uint32 spellid,uint64 guid); void Unit::EventSummonPetExpire(); uint8 Unit::CastSpell(Unit* Target, SpellEntry* Sp, bool triggered); uint8 Unit::CastSpell(Unit* Target, uint32 SpellID, bool triggered); uint8 Unit::CastSpell(uint64 targetGuid, SpellEntry* Sp, bool triggered); uint8 Unit::CastSpell(uint64 targetGuid, uint32 SpellID, bool triggered); void Unit::CastSpellAoF(float x,float y,float z,SpellEntry* Sp, bool triggered); void Unit::PlaySpellVisual(uint64 target, uint32 spellVisual); void Unit::Root(); void Unit::Unroot(); void Unit::RemoveAurasByBuffType(uint32 buff_type, const uint64 &guid, uint32 skip); void Unit::RemoveAurasByBuffIndexType(uint32 buff_index_type, const uint64 &guid); bool Unit::HasAurasOfBuffType(uint32 buff_type, const uint64 &guid,uint32 skip); AuraCheckResponse Unit::AuraCheck(uint32 name_hash, uint32 rank, Object *caster); AuraCheckResponse Unit::AuraCheck(uint32 name_hash, uint32 rank, Aura* aur, Object *caster); void Unit::OnPushToWorld(); void Unit::RemoveFromWorld(bool free_guid); void Unit::RemoveAurasByInterruptFlagButSkip(uint32 flag, uint32 skip); int Unit::HasAurasWithNameHash(uint32 name_hash); bool Unit::HasNegativeAuraWithNameHash(uint32 name_hash); bool Unit::HasNegativeAura(uint32 spell_id); uint32 Unit::CountNegativeAura(uint32 spell_id); bool Unit::IsPoisoned(); uint32 Unit::AddAuraVisual(uint32 spellid, uint32 count, bool positive); void Unit::SetAuraSlotLevel(uint32 slot, bool positive); void Unit::RemoveAuraVisual(uint32 spellid, uint32 count); uint32 Unit::ModAuraStackCount(uint32 slot, int32 count); void Unit::RemoveAurasOfSchool(uint32 School, bool Positive, bool Immune); void Unit::EnableFlight(); void Unit::DisableFlight(); bool Unit::IsDazed(); void Unit::UpdateVisibility(); void Unit::RemoveSoloAura(uint32 type); void Unit::EventHealthChangeSinceLastUpdate(); int32 Unit::GetAP(); int32 Unit::GetRAP(); bool Unit::GetSpeedDecrease(); void Unit::EventCastSpell(Unit * Target, SpellEntry * Sp); void Unit::SetFacing(float newo); Unit* Unit::create_guardian( uint32 guardian_entry, uint32 duration, float angle, uint32 lvl, GameObject * obj, Spell * spell_callback ); float Unit::get_chance_to_daze(Unit *target); void CombatStatusHandler::ClearMyHealers(); void CombatStatusHandler::WeHealed(Unit * pHealTarget); void CombatStatusHandler::RemoveHealed(Unit * pHealTarget); void CombatStatusHandler::UpdateFlag(); bool CombatStatusHandler::InternalIsInCombat(); void CombatStatusHandler::AddAttackTarget(const uint64& guid); void CombatStatusHandler::ClearPrimaryAttackTarget(); bool CombatStatusHandler::IsAttacking(Unit * pTarget); void CombatStatusHandler::RemoveAttackTarget(Unit * pTarget); void CombatStatusHandler::RemoveAttacker(Unit * pAttacker, const uint64& guid); void CombatStatusHandler::OnDamageDealt(Unit * pTarget); void CombatStatusHandler::AddAttacker(const uint64& guid); void CombatStatusHandler::ClearAttackers(); void CombatStatusHandler::ClearHealers(); void CombatStatusHandler::OnRemoveFromWorld(); ASCENT_INLINE bool CombatStatusHandler::IsInCombat(); void Unit::CombatStatusHandler_ResetPvPTimeout(); void Unit::CombatStatusHandler_UpdatePvPTimeout(); void Unit::Heal(Unit *target, uint32 SpellId, uint32 amount); void Unit::Energize( Unit* target, uint32 SpellId, uint32 amount, uint32 type ); void Unit::InheritSMMods(Unit *inherit_from); void CombatStatusHandler::TryToClearAttackTargets(); void CombatStatusHandler::AttackersForgetHate(); void Unit::CancelSpell(Spell * ptr); void Unit::EventStrikeWithAbility(uint64 guid, SpellEntry * sp, uint32 damage); void Unit::DispelAll(bool positive); bool Unit::RemoveAllAurasByMechanic( uint32 MechanicType , uint32 MaxDispel = -1 , bool HostileOnly = true ); void Unit::setAttackTimer(int32 time, bool offhand); bool Unit::isAttackReady(bool offhand); void Unit::SetHover(bool on); void Unit::RemoveAurasDueToSpell(uint32 spellId); void Unit::ReplaceAIInterface(AIInterface *new_interface); void Unit::EventUpdateFlag(); bool Unit::HasAurasOfNameHashWithCaster(uint32 namehash, Unit * caster); void Unit::EventModelChange(); void Unit::RemoveFieldSummon(); bool Unit::RemovePositiveAura(uint32 spellId); bool Unit::RemoveNegativeAura(uint32 spellId); void Unit::Paralyze(bool apply); void Unit::EventStunOrImmobilize(Unit *proc_target, bool is_victim); void Unit::EventChill(Unit *proc_target, bool is_victim); void Unit::RemoveExtraStrikeTarget(SpellEntry *spell_info); void Unit::AddExtraStrikeTarget(SpellEntry *spell_info, uint32 charges); uint32 Unit::DoDamageSplitTarget(uint32 res, uint32 school_type, bool melee_dmg); uint32 Unit::GetAuraCount(uint32 spellId); Unit *Unit::GetOwner(); Unit *Unit::GetCharmer(); Player* Unit::GetCharmerOrOwnerPlayerOrPlayerItself();

1e43503d7064a8910277b93785e1e982e6c391f66715ee4d3502e095f5ce962f

Ultis

simulationcraft

engine/sc_warlock.cpp

trigger_tier12_4pc_caster

static void trigger_tier12_4pc_caster( spell_t* s ) { warlock_t* p = s -> player -> cast_warlock(); if ( ! p -> set_bonus.tier12_4pc_caster() ) return; p -> buffs_tier12_4pc_caster -> trigger( 1, p -> tier12_4pc_caster -> effect1().percent() ); }

warlock_t( sim_t* sim, const std::string& name, race_type r = RACE_NONE ); int affliction_effects(); int active_dots(); double get_attribute_base( int level, int stat_type, pet_type_t pet_type ); double get_weapon( int level, pet_type_t pet_type, int n ); warlock_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt, bool guardian = false ); virtual void init_base(); virtual void init_resources( bool force ); virtual void schedule_ready( double delta_time=0, bool waiting=false ); virtual void summon( double duration=0 ); virtual void dismiss(); virtual double composite_spell_haste(); virtual double composite_attack_haste(); virtual double composite_spell_power( const school_type school ); virtual double composite_attack_power(); virtual double composite_attack_crit(); virtual double composite_spell_crit(); warlock_main_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt ); virtual void summon( double duration=0 ); virtual void dismiss(); virtual double composite_attack_expertise(); virtual double composite_player_multiplier( const school_type school, action_t* a ); virtual double composite_mp5(); warlock_guardian_pet_t( sim_t* sim, player_t* owner, const std::string& pet_name, pet_type_t pt ); virtual void summon( double duration=0 ); virtual double composite_attack_crit(); virtual double composite_attack_expertise(); virtual double composite_attack_haste(); virtual double composite_attack_hit(); virtual double composite_attack_power(); virtual double composite_spell_crit(); virtual double composite_spell_haste(); virtual double composite_spell_power( const school_type school ); virtual double composite_spell_power_multiplier(); warlock_heal_t( const char* n, warlock_t* p, const uint32_t id ); virtual void player_buff(); void _init_warlock_spell_t(); warlock_spell_t( const char* n, warlock_t* p, const school_type s, int t ); warlock_spell_t( const active_spell_t& s, int t = TREE_NONE ); warlock_spell_t( const char* n, warlock_t* p, const char* sname, int t = TREE_NONE ); warlock_spell_t( const char* n, warlock_t* p, const uint32_t id, int t = TREE_NONE ); virtual double haste(); virtual void player_buff(); virtual void target_debuff( player_t* t, int dmg_type ); virtual void tick( dot_t* d ); virtual double total_td_multiplier(); static void trigger_impending_doom ( spell_t* s ); static void trigger_soul_leech( spell_t* s ); static void trigger_decimation( warlock_spell_t* s, int result ); static double trigger_deaths_embrace( spell_t* s ); static void trigger_everlasting_affliction( spell_t* s ); static void trigger_fiery_imp( spell_t* s ); warlock_pet_melee_t( warlock_pet_t* p, const char* name ); warlock_pet_attack_t( const char* n, warlock_pet_t* p, int r=RESOURCE_MANA, const school_type s=SCHOOL_PHYSICAL ); warlock_pet_attack_t( const char* n, player_t* player, const char* sname, int t = TREE_NONE ); warlock_pet_attack_t( const char* n, const uint32_t id, player_t* player, int t = TREE_NONE ); virtual void player_buff(); void trigger_mana_feed( action_t* s, double impact_result ); warlock_pet_spell_t( const char* n, warlock_pet_t* p, int r=RESOURCE_MANA, const school_type s=SCHOOL_SHADOW ); warlock_pet_spell_t( const active_spell_t& s, int t = TREE_NONE ); warlock_pet_spell_t( const char* n, warlock_pet_t* p, const char* sname, int t = TREE_NONE ); warlock_pet_spell_t( const char* n, const uint32_t id, warlock_pet_t* p, int t = TREE_NONE ); virtual void player_buff(); firebolt_t( imp_pet_t* p ); virtual void player_buff(); imp_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); legion_strike_t( felguard_pet_t* p ); virtual void execute(); virtual void player_buff(); felstorm_tick_t( felguard_pet_t* p ); felstorm_t( felguard_pet_t* p ); virtual void tick( dot_t* d ); melee_t( felguard_pet_t* p ); felguard_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); shadow_bite_t( felhunter_pet_t* p ); virtual void player_buff(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); felhunter_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); virtual void summon( double duration=0 ); virtual void dismiss(); lash_of_pain_t( succubus_pet_t* p ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual void player_buff(); succubus_pet_t( sim_t* sim, player_t* owner ); virtual action_t* create_action( const std::string& name, const std::string& options_str ); torment_t( voidwalker_pet_t* p ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); voidwalker_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); immolation_damage_t( infernal_pet_t* p ); infernal_immolation_t( infernal_pet_t* p, const std::string& options_str ); virtual void tick( dot_t* d ); infernal_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); doom_bolt_t( doomguard_pet_t* p ); doomguard_pet_t( sim_t* sim, player_t* owner ); virtual void init_base(); virtual action_t* create_action( const std::string& name, const std::string& options_str ); virtual double composite_player_multiplier( const school_type school, action_t* a ); ebon_imp_pet_t( sim_t* sim, player_t* owner ); virtual double composite_attack_power(); virtual void init_base(); fiery_imp_pet_t( sim_t* sim, player_t* owner ); virtual void summon( double duration=0 ); virtual double composite_spell_crit(); virtual double composite_spell_haste(); flame_blast_t( fiery_imp_pet_t* p ); virtual action_t* create_action( const std::string& name, const std::string& options_str ); virtual void expire(); curse_of_elements_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); bane_of_agony_t( warlock_t* p, const std::string& options_str ); virtual void execute(); bane_of_doom_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual void tick( dot_t* d ); bane_of_havoc_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); shadow_bolt_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual double execute_time(); virtual void schedule_execute(); virtual void execute(); virtual void player_buff(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual bool ready(); void trigger_burning_embers ( spell_t* s, double dmg ); chaos_bolt_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual double execute_time(); virtual void execute(); virtual void player_buff(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); death_coil_t( warlock_t* p, const std::string& options_str ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); shadowburn_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual void update_ready(); virtual bool ready(); shadowfury_t( warlock_t* p, const std::string& options_str ); corruption_t( warlock_t* p, const std::string& options_str ); virtual void player_buff(); virtual void tick( dot_t* d ); drain_life_heal_t( warlock_t* p ); virtual void execute(); virtual void player_buff(); drain_life_t( warlock_t* p, const std::string& options_str ); virtual void last_tick( dot_t* d); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual double tick_time(); virtual void player_buff(); virtual void tick( dot_t* d ); drain_soul_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual void tick( dot_t* d ); virtual void player_buff(); unstable_affliction_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual void tick( dot_t* d ); haunt_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); immolate_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void player_buff(); virtual void execute(); virtual void tick( dot_t* d ); shadowflame_dot_t( warlock_t* p ); shadowflame_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void execute(); conflagrate_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void execute(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual bool ready(); incinerate_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void execute(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual void player_buff(); virtual double execute_time(); searing_pain_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void player_buff(); virtual void execute(); soul_fire_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void execute(); virtual double execute_time(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); life_tap_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); demon_armor_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); fel_armor_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual void tick( dot_t* d ); virtual bool ready(); void _init_summon_pet_t( const std::string& options_str, const char* pet_name ); summon_pet_t( const char* n, warlock_t* p, const char* sname, const std::string& options_str="" ); summon_pet_t( const char* n, warlock_t* p, int id, const std::string& options_str="" ); virtual void execute(); summon_main_pet_t( const char* n, warlock_t* p, const char* sname, const std::string& options_str ); virtual void schedule_execute(); virtual bool ready(); virtual double execute_time(); virtual void execute(); summon_felhunter_t( warlock_t* p, const std::string& options_str ); summon_felguard_t( warlock_t* p, const std::string& options_str ); summon_succubus_t( warlock_t* p, const std::string& options_str ); summon_imp_t( warlock_t* p, const std::string& options_str ); summon_voidwalker_t( warlock_t* p, const std::string& options_str ); infernal_awakening_t( warlock_t* p ); summon_infernal_t( warlock_t* p, const std::string& options_str ); virtual void execute(); summon_doomguard2_t( warlock_t* p ); virtual void execute(); summon_doomguard_t( warlock_t* p, const std::string& options_str ); virtual void execute(); immolation_damage_t( warlock_t* p ); immolation_aura_t( warlock_t* p, const std::string& options_str ); virtual void tick( dot_t* d ); virtual bool ready(); metamorphosis_t( warlock_t* p, const std::string& options_str ); virtual void execute(); demonic_empowerment_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); hand_of_guldan_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual double travel_time(); fel_flame_t( warlock_t* p, const std::string& options_str, bool dtr=false ); virtual void execute(); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual void player_buff(); dark_intent_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); soulburn_t( warlock_t* p, const std::string& options_str ); virtual void execute(); demon_soul_t( warlock_t* p, const std::string& options_str ); virtual void execute(); virtual bool ready(); hellfire_tick_t( warlock_t* p ); hellfire_t( warlock_t* p, const std::string& options_str ); virtual bool usable_moving(); virtual void tick( dot_t* /* d */ ); seed_of_corruption_aoe_t( warlock_t* p ); virtual void execute(); seed_of_corruption_t( warlock_t* p, const std::string& options_str ); virtual void impact( player_t* t, int impact_result, double travel_dmg ); virtual void tick( dot_t* d ); rain_of_fire_tick_t( warlock_t* p ); rain_of_fire_t( warlock_t* p, const std::string& options_str ); virtual void tick( dot_t* d ); void imp_pet_t::firebolt_t::impact( player_t* t, int impact_result, double travel_dmg ); double warlock_t::composite_armor(); double warlock_t::composite_spell_power( const school_type school ); double warlock_t::composite_spell_power_multiplier(); double warlock_t::composite_player_multiplier( const school_type school, action_t* a ); double warlock_t::composite_player_td_multiplier( const school_type school, action_t* a ); double warlock_t::matching_gear_multiplier( const attribute_type attr ); void warlock_t::create_pets(); void warlock_t::init_talents(); void warlock_t::init_spells(); void warlock_t::init_base(); void warlock_t::init_scaling(); void warlock_t::init_buffs(); void warlock_t::init_values(); void warlock_t::init_gains(); void warlock_t::init_benefits(); void warlock_t::init_procs(); void warlock_t::init_rng(); void warlock_t::init_actions(); void warlock_t::init_resources( bool force ); void warlock_t::reset(); action_expr_t* warlock_t::create_expression( action_t* a, const std::string& name_str ); void warlock_t::create_options(); bool warlock_t::create_profile( std::string& profile_str, int save_type, bool save_html ); void warlock_t::copy_from( player_t* source ); int warlock_t::decode_set( item_t& item ); player_t* player_t::create_warlock( sim_t* sim, const std::string& name, race_type r ); void player_t::warlock_init( sim_t* sim ); void player_t::warlock_combat_begin( sim_t* sim );

89cc61ffcb5de3d76dd6251968b02fe032ba53ef46607588caebbbcef99e55b3

devintCo

ccv15_dvn

addons/ofxMultiplexer/src/ofxMultiplexer.cpp

ofxMultiplexer::ofxMultiplexer

ofxMultiplexer::ofxMultiplexer() { offsetMap = NULL; weightMap = NULL; stitchedFrame = NULL; cameraFrames = NULL; cameraMap = NULL; cameraFramesWidth = NULL; cameraFramesHeight = NULL; cameras = NULL; blackCapturingMode = NULL; cameraCalibrationPoints = NULL; calibratingMode = false; }

ofxMultiplexer::~ofxMultiplexer(); void ofxMultiplexer::setIsCalibrationMode(bool isCalibrating); void ofxMultiplexer::getIsCalibrationMode(bool* isCalibrating); void ofxMultiplexer::setCalibrationPointsToCamera(int index,vector2df* calibrationPoints); void ofxMultiplexer::initializeMultiplexer(); void ofxMultiplexer::deinitializeMultiplexer(); void ofxMultiplexer::addCameraBase(ofxCameraBaseCalibration* settings); void ofxMultiplexer::removeCameraBase(ofxCameraBaseCalibration* settings); void ofxMultiplexer::removeCameraBase(int index); void ofxMultiplexer::clearAllCameraBase(); void ofxMultiplexer::startStreamingFromCamera(int index); void ofxMultiplexer::pauseStreamingFromCamera(int index); void ofxMultiplexer::startStreamingFromAllCameras(); void ofxMultiplexer::pauseStreamingFromAllCameras(); void ofxMultiplexer::updateStitchedFrame(); void ofxMultiplexer::getStitchedFrame(int* width,int* height,unsigned char* frameData); void ofxMultiplexer::setCameraGridSize(int width,int height); void ofxMultiplexer::getCameraGridSize(int* width,int* height); void ofxMultiplexer::setCalibrationGridSize(int width,int height); void ofxMultiplexer::getCalibrationGridSize(int* width,int* height); void ofxMultiplexer::setStitchedFrameSize(int width, int height); void ofxMultiplexer::getStitchedFrameSize(int* width,int* height); void ofxMultiplexer::computeDistortion(); void ofxMultiplexer::computeCameraMaps(); void ofxMultiplexer::computeWeightMap(float* cameraWeightMap,vector2df* calibrationPoints,int cameraPosition); void ofxMultiplexer::computeOffsetMap(unsigned int* cameraOffsetMap,vector2df* calibrationPoints,int cameraPosition); void ofxMultiplexer::cameraToScreenSpace(unsigned int &x, unsigned int &y,vector2df* screenPoints,vector2df* cameraPoints,int* triangles); void ofxMultiplexer::setInterleaveMode(bool isInterlaveMode); void ofxMultiplexer::getInterleaveMode(bool* isInterleaveMode); bool ofxMultiplexer::isPointInTriangle(vector2df p, vector2df a, vector2df b, vector2df c); int ofxMultiplexer::findTriangleWithin(vector2df pt,vector2df* screenPoints,int* triangles);

2eea450b4b56d0ad9b893810a7b3c970db6e863fee710f6a080c002cc0d35aa1

blefaudeux

RBDOOM-3-BFG

neo/d3xp/Player.cpp

idPlayer::Event_SelectWeapon

void idPlayer::Event_SelectWeapon( const char* weaponName ) { int i; int weaponNum; if( common->IsClient() ) { gameLocal.Warning( "Cannot switch weapons from script in multiplayer" ); return; } if( hiddenWeapon && gameLocal.world->spawnArgs.GetBool( "no_Weapons" ) ) { idealWeapon = weapon_fists; weapon.GetEntity()->HideWeapon(); return; } weaponNum = -1; for( i = 0; i < MAX_WEAPONS; i++ ) { if( inventory.weapons & ( 1 << i ) ) { const char* weap = spawnArgs.GetString( va( "def_weapon%d", i ) ); if( !idStr::Cmp( weap, weaponName ) ) { weaponNum = i; break; } } } if( weaponNum < 0 ) { gameLocal.Warning( "%s is not carrying weapon '%s'", name.c_str(), weaponName ); return; } hiddenWeapon = false; idealWeapon = weaponNum; UpdateHudWeapon(); }

void idInventory::Clear(); void idInventory::GivePowerUp( idPlayer* player, int powerup, int msec ); void idInventory::ClearPowerUps(); void idInventory::GetPersistantData( idDict& dict ); void idInventory::RestoreInventory( idPlayer* owner, const idDict& dict ); void idInventory::Save( idSaveGame* savefile ); void idInventory::Restore( idRestoreGame* savefile ); ammo_t idInventory::AmmoIndexForAmmoClass( const char* ammo_classname ); int idInventory::MaxAmmoForAmmoClass( const idPlayer* owner, const char* ammo_classname ); const char* idInventory::AmmoPickupNameForIndex( ammo_t ammonum ); int idInventory::WeaponIndexForAmmoClass( const idDict& spawnArgs, const char* ammo_classname ); ammo_t idInventory::AmmoIndexForWeaponClass( const char* weapon_classname, int* ammoRequired ); void idInventory::AddPickupName( const char* name, idPlayer* owner ); void idInventory::Drop( const idDict& spawnArgs, const char* weapon_classname, int weapon_index ); int idInventory::HasAmmo( ammo_t type, int amount ); int idInventory::HasAmmo( const char* weapon_classname, bool includeClip, idPlayer* owner ); bool idInventory::HasEmptyClipCannotRefill( const char* weapon_classname, idPlayer* owner ); bool idInventory::UseAmmo( ammo_t type, int amount ); void idInventory::UpdateArmor(); void idInventory::InitRechargeAmmo( idPlayer* owner ); void idInventory::RechargeAmmo( idPlayer* owner ); bool idInventory::CanGive( idPlayer* owner, const idDict& spawnArgs, const char* statname, const char* value ); void idInventory::SetClipAmmoForWeapon( const int weapon, const int amount ); void idInventory::SetInventoryAmmoForType( int ammoType, const int amount ); int idInventory::GetClipAmmoForWeapon( const int weapon ); int idInventory::GetInventoryAmmoForType( const int ammoType ); void idInventory::WriteAmmoToSnapshot( idBitMsg& msg ); void idInventory::ReadAmmoFromSnapshot( const idBitMsg& msg, const int ownerEntityNumber ); void idInventory::SetRemoteClientAmmo( const int ownerEntityNumber ); idPlayer::idPlayer(); void idPlayer::LinkScriptVariables(); void idPlayer::SetupWeaponEntity(); void idPlayer::Init(); void idPlayer::Spawn(); idPlayer::~idPlayer(); void idPlayer::Save( idSaveGame* savefile ); void idPlayer::Restore( idRestoreGame* savefile ); void idPlayer::PrepareForRestart(); void idPlayer::Restart(); void idPlayer::ServerSpectate( bool spectate ); void idPlayer::SelectInitialSpawnPoint( idVec3& origin, idAngles& angles ); void idPlayer::SpawnFromSpawnSpot(); void idPlayer::SpawnToPoint( const idVec3& spawn_origin, const idAngles& spawn_angles ); void idPlayer::Respawn_Shared(); void idPlayer::SavePersistantInfo(); void idPlayer::RestorePersistantInfo(); void idPlayer::UpdateSkinSetup(); void idPlayer::UpdateHudStats( idMenuHandler_HUD* _hudManager ); void idPlayer::UpdateHudWeapon( bool flashWeapon ); void idPlayer::UpdateChattingHud(); void idPlayer::UpdateSpectatingText(); void idPlayer::AddChatMessage( int index, int alpha, const idStr& message ); void idPlayer::ClearChatMessage( int index ); void idPlayer::DrawHUD( idMenuHandler_HUD* _hudManager ); void idPlayer::EnterCinematic(); void idPlayer::ExitCinematic(); void idPlayer::UpdateConditions(); void idPlayer::WeaponFireFeedback( const idDict* weaponDef ); void idPlayer::StopFiring(); void idPlayer::FireWeapon(); void idPlayer::CacheWeapons(); void idPlayer::SetQuickSlot( int index, int val ); int idPlayer::GetQuickSlot( int index ); bool idPlayer::Give( const char* statname, const char* value, unsigned int giveFlags ); void idPlayer::GiveHealthPool( float amt ); bool idPlayer::GiveItem( idItem* item, unsigned int giveFlags ); float idPlayer::PowerUpModifier( int type ); bool idPlayer::PowerUpActive( int powerup ); bool idPlayer::GivePowerUp( int powerup, int time, unsigned int giveFlags ); void idPlayer::ClearPowerup( int i ); void idPlayer::UpdatePowerUps(); void idPlayer::ClearPowerUps(); bool idPlayer::GiveInventoryItem( idDict* item, unsigned int giveFlags ); bool idPlayer::GiveInventoryItem( const char* name ); void idPlayer::GiveObjective( const char* title, const char* text, const idMaterial* screenshot ); void idPlayer::CompleteObjective( const char* title ); void idPlayer::GiveVideo( const idDeclVideo* video, const char* itemName ); void idPlayer::GiveSecurity( const char* security ); void idPlayer::GiveEmail( const idDeclEmail* email ); void idPlayer::GivePDA( const idDeclPDA* pda, const char* securityItem ); idDict* idPlayer::FindInventoryItem( const char* name ); idDict* idPlayer::FindInventoryItem( int index ); int idPlayer::GetNumInventoryItems(); void idPlayer::RemoveInventoryItem( const char* name ); void idPlayer::RemoveInventoryItem( idDict* item ); void idPlayer::GiveItem( const char* itemname ); int idPlayer::SlotForWeapon( const char* weaponName ); void idPlayer::Reload(); void idPlayer::NextBestWeapon(); void idPlayer::NextWeapon(); void idPlayer::PrevWeapon(); void idPlayer::SelectWeapon( int num, bool force ); void idPlayer::DropWeapon( bool died ); void idPlayer::StealWeapon( idPlayer* player ); idUserInterface* idPlayer::ActiveGui(); void idPlayer::Weapon_Combat(); void idPlayer::Weapon_NPC(); void idPlayer::LowerWeapon(); void idPlayer::RaiseWeapon(); void idPlayer::WeaponLoweringCallback(); void idPlayer::WeaponRisingCallback(); void idPlayer::Weapon_GUI(); void idPlayer::UpdateWeapon(); void idPlayer::UpdateFlashlight(); void idPlayer::FlashlightOn(); void idPlayer::FlashlightOff(); void idPlayer::SpectateFreeFly( bool force ); void idPlayer::SpectateCycle(); void idPlayer::UpdateSpectating(); bool idPlayer::HandleSingleGuiCommand( idEntity* entityGui, idLexer* src ); void idPlayer::PlayAudioLog( const idSoundShader* shader ); void idPlayer::EndAudioLog(); void idPlayer::PlayVideoDisk( const idDeclVideo* decl ); void idPlayer::EndVideoDisk(); bool idPlayer::Collide( const trace_t& collision, const idVec3& velocity ); void idPlayer::UpdateLocation(); void idPlayer::ClearFocus(); void idPlayer::UpdateFocus(); void idPlayer::CrashLand( const idVec3& oldOrigin, const idVec3& oldVelocity ); void idPlayer::BobCycle( const idVec3& pushVelocity ); void idPlayer::UpdateDeltaViewAngles( const idAngles& angles ); void idPlayer::SetViewAngles( const idAngles& angles ); void idPlayer::UpdateViewAngles(); void idPlayer::AdjustHeartRate( int target, float timeInSecs, float delay, bool force ); int idPlayer::GetBaseHeartRate(); void idPlayer::SetCurrentHeartRate(); void idPlayer::UpdateAir(); void idPlayer::UpdatePowerupHud(); const idDeclPDA* idPlayer::GetPDA(); const idDeclVideo* idPlayer::GetVideo( int index ); void idPlayer::TogglePDA(); void idPlayer::Spectate( bool spectate, bool force ); void idPlayer::SetClipModel(); void idPlayer::UseVehicle(); void idPlayer::PerformImpulse( int impulse ); void idPlayer::EvaluateControls(); void idPlayer::AdjustSpeed(); void idPlayer::AdjustBodyAngles(); void idPlayer::InitAASLocation(); void idPlayer::SetAASLocation(); void idPlayer::GetAASLocation( idAAS* aas, idVec3& pos, int& areaNum ); void idPlayer::Move_Interpolated( float fraction ); void idPlayer::Move(); bool idPlayer::AllowClientAuthPhysics(); void idPlayer::RunPhysics_RemoteClientCorrection(); int idPlayer::GetPhysicsTimeStep(); void idPlayer::ShowRespawnHudMessage(); void idPlayer::HideRespawnHudMessage(); void idPlayer::UpdateHud(); void idPlayer::UpdateDeathSkin( bool state_hitch ); void idPlayer::StartFxOnBone( const char* fx, const char* bone ); bool idPlayer::HandleGuiEvents( const sysEvent_t* ev ); void idPlayer::UpdateLaserSight(); void idPlayer::Think(); void idPlayer::StartHealthRecharge( int speed ); void idPlayer::StopHealthRecharge(); idStr idPlayer::GetCurrentWeapon(); bool idPlayer::CanGive( const char* statname, const char* value ); void idPlayer::StopHelltime( bool quick ); void idPlayer::Event_ToggleBloom( int on ); void idPlayer::Event_SetBloomParms( float speed, float intensity ); void idPlayer::PlayHelltimeStopSound(); void idPlayer::RouteGuiMouse( idUserInterface* gui ); void idPlayer::LookAtKiller( idEntity* inflictor, idEntity* attacker ); void idPlayer::Kill( bool delayRespawn, bool nodamage ); void idPlayer::Killed( idEntity* inflictor, idEntity* attacker, int damage, const idVec3& dir, int location ); void idPlayer::GetAIAimTargets( const idVec3& lastSightPos, idVec3& headPos, idVec3& chestPos ); void idPlayer::DamageFeedback( idEntity* victim, idEntity* inflictor, int& damage ); void idPlayer::ControllerShakeFromDamage( int damage ); int idPlayer::AdjustDamageAmount( const int inputDamage ); void idPlayer::ServerDealDamage( int damage, idEntity& inflictor, idEntity& attacker, const idVec3& dir, const char* damageDefName, const int location ); void idPlayer::Teleport( const idVec3& origin, const idAngles& angles, idEntity* destination ); void idPlayer::SetPrivateCameraView( idCamera* camView ); float idPlayer::DefaultFov(); float idPlayer::CalcFov( bool honorZoom ); idAngles idPlayer::GunTurningOffset(); idVec3 idPlayer::GunAcceleratingOffset(); void idPlayer::CalculateViewWeaponPos( idVec3& origin, idMat3& axis ); void idPlayer::OffsetThirdPersonView( float angle, float range, float height, bool clip ); idVec3 idPlayer::GetEyePosition(); void idPlayer::GetViewPos( idVec3& origin, idMat3& axis ); void idPlayer::CalculateFirstPersonView(); renderView_t* idPlayer::GetRenderView(); void idPlayer::CalculateRenderView(); void idPlayer::AddAIKill(); void idPlayer::SetSoulCubeProjectile( idProjectile* projectile ); void idPlayer::AddProjectilesFired( int count ); void idPlayer::AddProjectileHits( int count ); void idPlayer::SetLastHitTime( int time ); void idPlayer::SetInfluenceLevel( int level ); void idPlayer::SetInfluenceView( const char* mtr, const char* skinname, float radius, idEntity* ent ); void idPlayer::SetInfluenceFov( float fov ); bool idPlayer::OnLadder(); void idPlayer::Event_GetButtons(); void idPlayer::Event_GetMove(); void idPlayer::Event_GetViewAngles(); void idPlayer::Event_StopFxFov(); void idPlayer::StartFxFov( float duration ); void idPlayer::Event_EnableWeapon(); void idPlayer::Event_DisableWeapon(); void idPlayer::Event_GiveInventoryItem( const char* name ); void idPlayer::Event_RemoveInventoryItem( const char* name ); void idPlayer::Event_GetIdealWeapon(); void idPlayer::Event_SetPowerupTime( int powerup, int time ); void idPlayer::Event_IsPowerupActive( int powerup ); void idPlayer::Event_StartWarp(); void idPlayer::Event_StopHelltime( int mode ); void idPlayer::Event_WeaponAvailable( const char* name ); bool idPlayer::WeaponAvailable( const char* name ); void idPlayer::Event_GetCurrentWeapon(); void idPlayer::Event_GetPreviousWeapon(); void idPlayer::Event_GetWeaponEntity(); void idPlayer::Event_OpenPDA(); void idPlayer::Event_InPDA(); void idPlayer::TeleportDeath( int killer ); void idPlayer::Event_ForceOrigin( idVec3& origin, idAngles& angles ); void idPlayer::Event_ExitTeleporter(); void idPlayer::ClientThink( const int curTime, const float fraction, const bool predict ); bool idPlayer::GetPhysicsToVisualTransform( idVec3& origin, idMat3& axis ); bool idPlayer::GetPhysicsToSoundTransform( idVec3& origin, idMat3& axis ); void idPlayer::HandleUserCmds( const usercmd_t& newcmd ); void idPlayer::WriteToSnapshot( idBitMsg& msg ); void idPlayer::ReadFromSnapshot( const idBitMsg& msg ); void idPlayer::WritePlayerStateToSnapshot( idBitMsg& msg ); void idPlayer::ReadPlayerStateFromSnapshot( const idBitMsg& msg ); bool idPlayer::ServerReceiveEvent( int event, int time, const idBitMsg& msg ); bool idPlayer::ClientReceiveEvent( int event, int time, const idBitMsg& msg ); void idPlayer::Hide(); void idPlayer::Show(); bool idPlayer::IsSoundChannelPlaying( const s_channelType channel ); void idPlayer::ShowTip( const char* title, const char* tip, bool autoHide ); void idPlayer::HideTip(); void idPlayer::Event_HideTip(); void idPlayer::HideObjective(); void idPlayer::Event_StopAudioLog(); void idPlayer::SetSpectateOrigin(); void idPlayer::RemoveWeapon( const char* weap ); void idPlayer::RemoveAllButEssentialWeapons(); bool idPlayer::CanShowWeaponViewmodel(); void idPlayer::SetLevelTrigger( const char* levelName, const char* triggerName ); void idPlayer::Event_LevelTrigger(); void idPlayer::Event_Gibbed(); void idPlayer::UpdatePlayerIcons(); void idPlayer::DrawPlayerIcons(); void idPlayer::HidePlayerIcons(); bool idPlayer::NeedsIcon(); void idPlayer::DropFlag(); void idPlayer::ReturnFlag(); void idPlayer::FreeModelDef(); void idPlayer::SetControllerShake( float highMagnitude, int highDuration, float lowMagnitude, int lowDuration ); void idPlayer::ResetControllerShake(); void idPlayer::GetControllerShake( int& highMagnitude, int& lowMagnitude ); gameExpansionType_t idPlayer::GetExpansionType();

dabb004ee0c62d4acc119ea955009cfe100f3c92d3f2c689cf8cad9a71f0b9c0

OPM

ResInsight

ApplicationLibCode/ProjectDataModel/AnalysisPlots/RimPlotDataFilterItem.cpp

RimPlotDataFilterItem::filterRangeMinMax

std::pair<double, double> RimPlotDataFilterItem::filterRangeMinMax() const { CVF_ASSERT( m_filterOperation() == RANGE ); return std::make_pair( m_min(), m_max() ); }

void caf::AppEnum<RimPlotDataFilterItem::FilterTarget>::setUp(); void caf::AppEnum<RimPlotDataFilterItem::FilterOperation>::setUp(); void caf::AppEnum<RimPlotDataFilterItem::TimeStepSourceType>::setUp(); RimPlotDataFilterItem::RimPlotDataFilterItem(); RimPlotDataFilterItem::~RimPlotDataFilterItem(); bool RimPlotDataFilterItem::isValid(); RifEclipseSummaryAddress RimPlotDataFilterItem::summaryAddress(); QString RimPlotDataFilterItem::ensembleParameterName(); int RimPlotDataFilterItem::topBottomN(); std::vector<QString> RimPlotDataFilterItem::selectedEnsembleParameterCategories(); RimPlotDataFilterItem::TimeStepSourceType RimPlotDataFilterItem::consideredTimeStepsType(); std::pair<time_t, time_t> RimPlotDataFilterItem::timeRangeMinMax(); std::vector<time_t> RimPlotDataFilterItem::explicitlySelectedTimeSteps(); QList<caf::PdmOptionItemInfo> RimPlotDataFilterItem::calculateValueOptions( const caf::PdmFieldHandle* fieldNeedingOptions ); caf::PdmFieldHandle* RimPlotDataFilterItem::objectToggleField(); void RimPlotDataFilterItem::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ); void RimPlotDataFilterItem::updateMaxMinAndDefaultValues( bool forceDefault ); RigEnsembleParameter RimPlotDataFilterItem::selectedEnsembleParameter();

0cea3844c4efaf301492a0a88380a763659b6a54e1e77af067b2ec71bbe84305

cp1337

devland

ban.cpp

Ban::getPlayerBans

const PlayerBanList& Ban::getPlayerBans() { return playerBanList; }

Ban::Ban(); void Ban::init(); bool Ban::isIpBanished(uint32_t clientip); bool Ban::isIpDisabled(uint32_t clientip); bool Ban::acceptConnection(uint32_t clientip); void Ban::addLoginAttempt(uint32_t clientip, bool isSuccess); bool Ban::isPlayerBanished(const std::string& name); bool Ban::isAccountBanished(uint32_t account); void Ban::addIpBan(uint32_t ip, uint32_t mask, uint32_t time); void Ban::addPlayerBan(uint32_t playerId, uint32_t time); void Ban::addAccountBan(uint32_t account, uint32_t time); bool Ban::removeIpBan(uint32_t n); bool Ban::removePlayerBan(uint32_t n); bool Ban::removeAccountBan(uint32_t n); const IpBanList& Ban::getIpBans(); const AccountBanList& Ban::getAccountBans(); bool Ban::loadBans(); bool Ban::saveBans(); bool IOBan::loadBans(Ban& banclass); bool IOBan::saveBans(const Ban& banclass);

eb77d2c35c515f74b35040c2eceecb1ec599838f027ecef75cbf029c024e3228

RomanKubiak

ctrlr

JUCE/modules/juce_audio_plugin_client/VST/juce_VST_Wrapper.cpp

setParameterCB

static void setParameterCB (Vst2::AEffect* vstInterface, int32 index, float value) { getWrapper (vstInterface)->setParameter (index, value); }

static HWND findMDIParentOf (HWND w); SharedMessageThread(); ~SharedMessageThread(); void run(); void internalProcessReplacing (FloatType** inputs, FloatType** outputs, int32 numSamples, VstTempBuffers<FloatType>& tmpBuffers); void processReplacing (float** inputs, float** outputs, int32 sampleFrames); static void processReplacingCB (Vst2::AEffect* vstInterface, float** inputs, float** outputs, int32 sampleFrames); void processDoubleReplacing (double** inputs, double** outputs, int32 sampleFrames); static void processDoubleReplacingCB (Vst2::AEffect* vstInterface, double** inputs, double** outputs, int32 sampleFrames); void resume(); void suspend(); bool getCurrentPosition (AudioPlayHead::CurrentPositionInfo& info); float getParameter (int32 index); static float getParameterCB (Vst2::AEffect* vstInterface, int32 index); void setParameter (int32 index, float value); void audioProcessorParameterChanged (AudioProcessor*, int index, float newValue); void audioProcessorParameterChangeGestureBegin (AudioProcessor*, int index); void audioProcessorParameterChangeGestureEnd (AudioProcessor*, int index); void parameterValueChanged (int, float newValue); void audioProcessorChanged (AudioProcessor*, const ChangeDetails& details); bool getPinProperties (Vst2::VstPinProperties& properties, bool direction, int index); void timerCallback(); void setHasEditorFlag (bool shouldSetHasEditor); void createEditorComp(); void deleteEditor (bool canDeleteLaterIfModal); pointer_sized_int dispatcher (int32 opCode, VstOpCodeArguments args); static pointer_sized_int dispatcherCB (Vst2::AEffect* vstInterface, int32 opCode, int32 index, pointer_sized_int value, void* ptr, float opt); EditorCompWrapper (JuceVSTWrapper& w, AudioProcessorEditor& editor); ~EditorCompWrapper(); void paint (Graphics& g); void getEditorBounds (Vst2::ERect& bounds); void attachToHost (VstOpCodeArguments args); void detachHostWindow(); void checkVisibility(); AudioProcessorEditor* getEditorComp(); void resized(); void parentSizeChanged(); void childBoundsChanged (Component*); juce::Rectangle<int> getSizeToContainChild(); void updateWindowSize(); void resizeHostWindow (int newWidth, int newHeight); void setContentScaleFactor (float scale); void mouseDown (const MouseEvent&); void broughtToFront(); void checkHostWindowScaleFactor(); void timerCallback(); bool keyPressed (const KeyPress&); void update (const ChangeDetails& details); bool isProcessLevelOffline(); static int32 convertHexVersionToDecimal (const unsigned int hexVersion); static void checkWhetherMessageThreadIsCorrect(); void deleteTempChannels (VstTempBuffers<FloatType>& tmpBuffers); void deleteTempChannels(); void findMaxTotalChannels (int& maxTotalIns, int& maxTotalOuts); pointer_sized_int handleOpen (VstOpCodeArguments); pointer_sized_int handleClose (VstOpCodeArguments); pointer_sized_int handleSetCurrentProgram (VstOpCodeArguments args); pointer_sized_int handleGetCurrentProgram (VstOpCodeArguments); pointer_sized_int handleSetCurrentProgramName (VstOpCodeArguments args); pointer_sized_int handleGetCurrentProgramName (VstOpCodeArguments args); pointer_sized_int handleGetParameterLabel (VstOpCodeArguments args); pointer_sized_int handleGetParameterText (VstOpCodeArguments args); pointer_sized_int handleGetParameterName (VstOpCodeArguments args); pointer_sized_int handleSetSampleRate (VstOpCodeArguments args); pointer_sized_int handleSetBlockSize (VstOpCodeArguments args); pointer_sized_int handleResumeSuspend (VstOpCodeArguments args); pointer_sized_int handleGetEditorBounds (VstOpCodeArguments args); pointer_sized_int handleOpenEditor (VstOpCodeArguments args); pointer_sized_int handleCloseEditor (VstOpCodeArguments); pointer_sized_int handleGetData (VstOpCodeArguments args); pointer_sized_int handleSetData (VstOpCodeArguments args); pointer_sized_int handlePreAudioProcessingEvents (VstOpCodeArguments args); pointer_sized_int handleIsParameterAutomatable (VstOpCodeArguments args); pointer_sized_int handleParameterValueForText (VstOpCodeArguments args); pointer_sized_int handleGetProgramName (VstOpCodeArguments args); pointer_sized_int handleGetInputPinProperties (VstOpCodeArguments args); pointer_sized_int handleGetOutputPinProperties (VstOpCodeArguments args); pointer_sized_int handleGetPlugInCategory (VstOpCodeArguments); pointer_sized_int handleSetSpeakerConfiguration (VstOpCodeArguments args); pointer_sized_int handleSetBypass (VstOpCodeArguments args); pointer_sized_int handleGetPlugInName (VstOpCodeArguments args); pointer_sized_int handleGetManufacturerName (VstOpCodeArguments args); pointer_sized_int handleGetManufacturerVersion (VstOpCodeArguments); pointer_sized_int handleManufacturerSpecific (VstOpCodeArguments args); pointer_sized_int handleCanPlugInDo (VstOpCodeArguments args); pointer_sized_int handleGetTailSize (VstOpCodeArguments); pointer_sized_int handleKeyboardFocusRequired (VstOpCodeArguments); pointer_sized_int handleGetVstInterfaceVersion (VstOpCodeArguments); pointer_sized_int handleGetCurrentMidiProgram (VstOpCodeArguments); pointer_sized_int handleGetSpeakerConfiguration (VstOpCodeArguments args); pointer_sized_int handleSetNumberOfSamplesToProcess (VstOpCodeArguments args); pointer_sized_int handleSetSampleFloatType (VstOpCodeArguments args); pointer_sized_int handleSetContentScaleFactor (float scale); pointer_sized_int handleGetNumMidiInputChannels(); pointer_sized_int handleGetNumMidiOutputChannels(); Vst2::AEffect* pluginEntryPoint (Vst2::audioMasterCallback audioMaster); JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster); JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_macho (Vst2::audioMasterCallback audioMaster); JUCE_EXPORTED_FUNCTION Vst2::AEffect* VSTPluginMain (Vst2::audioMasterCallback audioMaster); JUCE_EXPORTED_FUNCTION Vst2::AEffect* main_plugin (Vst2::audioMasterCallback audioMaster); __declspec (dllexport); __declspec (dllexport); BOOL WINAPI DllMain (HINSTANCE instance, DWORD reason, LPVOID);

b1d9177424561951601acd8555e3f8427f5c2a921d3d1040dbf22d3cc9407c84

realXtend

tundra-urho3d

src/TundraCore/Scene/IComponent.cpp

IComponent::BeginSerialization

Urho3D::XMLElement IComponent::BeginSerialization(Urho3D::XMLFile& doc, Urho3D::XMLElement& base_element, bool serializeTemporary) const { Urho3D::XMLElement comp_element; if (!base_element) comp_element = doc.CreateRoot("component"); else comp_element = base_element.CreateChild("component"); comp_element.SetAttribute("type", EnsureTypeNameWithoutPrefix(TypeName())); comp_element.SetUInt("typeId", TypeId()); if (!componentName.Empty()) comp_element.SetAttribute("name", componentName); comp_element.SetBool("sync", replicated); if (serializeTemporary) comp_element.SetBool("temporary", temporary); return comp_element; }

IComponent::IComponent(Urho3D::Context* context, Scene* scene); IComponent::~IComponent(); void IComponent::SetNewId(entity_id_t newId); void IComponent::SetName(const String& name_); bool IComponent::IsUnacked(); void IComponent::SetUpdateMode(AttributeChange::Type defaultMode); void IComponent::SetParentEntity(Entity* entity); Entity* IComponent::ParentEntity(); Scene* IComponent::ParentScene(); void IComponent::SetReplicated(bool enable); void IComponent::SetAttribute(const String& id, const Variant& value, AttributeChange::Type change); Variant IComponent::GetAttribute(const String& id); AttributeVector IComponent::NonEmptyAttributes(); StringVector IComponent::AttributeNames(); StringVector IComponent::AttributeIds(); bool IComponent::ShouldBeSerialized(bool serializeTemporary, bool serializeLocal); IAttribute* IComponent::AttributeById(const String &id); IAttribute* IComponent::AttributeByName(const String &name); int IComponent::NumAttributes(); int IComponent::NumStaticAttributes(); IAttribute* IComponent::CreateAttribute(u8 index, u32 typeID, const String& id, AttributeChange::Type change); void IComponent::RemoveAttribute(u8 index, AttributeChange::Type change); void IComponent::AddAttribute(IAttribute* attr); bool IComponent::AddAttribute(IAttribute* attr, u8 index); void IComponent::DeserializeAttributeFrom(Urho3D::XMLElement& attributeElement, AttributeChange::Type change); void IComponent::WriteAttribute(Urho3D::XMLFile& /*doc*/, Urho3D::XMLElement& comp_element, const String& name, const String& id, const String& value, const String &type); void IComponent::WriteAttribute(Urho3D::XMLFile& doc, Urho3D::XMLElement& compElement, const IAttribute *attr); bool IComponent::BeginDeserialization(Urho3D::XMLElement& compElem); void IComponent::EmitAttributeChanged(IAttribute* attribute, AttributeChange::Type change); void IComponent::EmitAttributeMetadataChanged(IAttribute* attribute); void IComponent::EmitAttributeChanged(const String& attributeName, AttributeChange::Type change); void IComponent::SerializeTo(Urho3D::XMLFile& doc, Urho3D::XMLElement& base_element, bool serializeTemporary); void IComponent::DeserializeFrom(Urho3D::XMLElement& element, AttributeChange::Type change); void IComponent::SerializeToBinary(kNet::DataSerializer& dest); void IComponent::DeserializeFromBinary(kNet::DataDeserializer& source, AttributeChange::Type change); void IComponent::ComponentChanged(AttributeChange::Type change); void IComponent::SetTemporary(bool enable); bool IComponent::IsTemporary(); bool IComponent::ViewEnabled();

1867cfe92c9e53dcc90b7c659604ade1b1c3280ce354ddf0b2f62ba6ad9e33dd

Max98

ror_dep_upgrade

source/main/scripting/ScriptEngine.cpp

ScriptEngine::functionExists

int ScriptEngine::functionExists(const String &arg) { if (!engine) return -1; if (!context) context = engine->CreateContext(); AngelScript::asIScriptModule *mod = engine->GetModule(moduleName, AngelScript::asGM_ONLY_IF_EXISTS); if (mod == 0) return AngelScript::asNO_FUNCTION; AngelScript::asIScriptFunction *f = mod->GetFunctionByDecl(arg.c_str()); if (f == 0) return AngelScript::asNO_FUNCTION; return f->GetTypeId(); }

void logString(const std::string &str); ScriptEngine::ScriptEngine(Collisions *coll); ScriptEngine::~ScriptEngine(); void ScriptEngine::ExceptionCallback(AngelScript::asIScriptContext *ctx, void *param); void ScriptEngine::exploreScripts(); void ScriptEngine::LineCallback(AngelScript::asIScriptContext *ctx, unsigned long *timeOut); void ScriptEngine::init(); void ScriptEngine::msgCallback(const AngelScript::asSMessageInfo *msg); int ScriptEngine::framestep(Real dt); int ScriptEngine::fireEvent(std::string instanceName, float intensity); int ScriptEngine::envokeCallback(int functionPtr, eventsource_t *source, node_t *node, int type); void ScriptEngine::queueStringForExecution(const String command); int ScriptEngine::executeString(String command); int ScriptEngine::addFunction(const String &arg); int ScriptEngine::deleteFunction(const String &arg); int ScriptEngine::addVariable(const String &arg); int ScriptEngine::deleteVariable(const String &arg); void ScriptEngine::triggerEvent(int eventnum, int value); int ScriptEngine::loadScript(String _scriptName); StringVector ScriptEngine::getAutoComplete(String command); void ScriptEngine::activateLogging();

5cc514dc63fd7310f76b2ace612b2892cce1d233c185632c998d2c0e7bb82f8c

amrnablus

PDF-Writer

PDFWriter/FreeTypeFaceWrapper.cpp

FreeTypeFaceWrapper::IOutlineEnumerator::outline_cubicto

int FreeTypeFaceWrapper::IOutlineEnumerator::outline_cubicto(const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to, void *closure) { return ( (FreeTypeFaceWrapper::IOutlineEnumerator *)closure )->FTCubicto(control1, control2, to) ? 0 : 1; }

FreeTypeFaceWrapper::FreeTypeFaceWrapper(FT_Face inFace,const std::string& inFontFilePath,long inFontIndex,bool inDoOwn); FreeTypeFaceWrapper::FreeTypeFaceWrapper(FT_Face inFace,const std::string& inFontFilePath,const std::string& inPFMFilePath,long inFontIndex, bool inDoOwn); std::string FreeTypeFaceWrapper::NotDefGlyphName(); std::string FreeTypeFaceWrapper::GetExtension(const std::string& inFilePath); FreeTypeFaceWrapper::~FreeTypeFaceWrapper(void); void FreeTypeFaceWrapper::SetupFormatSpecificExtender(const std::string& inFontFilePath,const std::string& inPFMFilePath /*pass empty if non existant or irrelevant*/); const char* FreeTypeFaceWrapper::GetTypeString(); FT_Face FreeTypeFaceWrapper::operator->(); FreeTypeFaceWrapper::operator FT_Face(); bool FreeTypeFaceWrapper::IsValid(); FT_Error FreeTypeFaceWrapper::DoneFace(); double FreeTypeFaceWrapper::GetItalicAngle(); BoolAndFTShort FreeTypeFaceWrapper::GetCapHeightInternal(); BoolAndFTShort FreeTypeFaceWrapper::GetCapHeight(); BoolAndFTShort FreeTypeFaceWrapper::CapHeightFromHHeight(); BoolAndFTShort FreeTypeFaceWrapper::GetxHeightInternal(); BoolAndFTShort FreeTypeFaceWrapper::GetxHeight(); BoolAndFTShort FreeTypeFaceWrapper::XHeightFromLowerXHeight(); BoolAndFTShort FreeTypeFaceWrapper::GetYBearingForUnicodeChar(unsigned short unicodeCharCode); FT_UShort FreeTypeFaceWrapper::GetStemV(); EFontStretch FreeTypeFaceWrapper::GetFontStretch(); EFontStretch FreeTypeFaceWrapper::StretchFromName(); FT_UShort FreeTypeFaceWrapper::GetFontWeight(); FT_UShort FreeTypeFaceWrapper::WeightFromName(); unsigned int FreeTypeFaceWrapper::GetFontFlags(); bool FreeTypeFaceWrapper::IsFixedPitch(); bool FreeTypeFaceWrapper::IsSerif(); bool FreeTypeFaceWrapper::IsSymbolic(); bool FreeTypeFaceWrapper::IsDefiningCharsNotInAdobeStandardLatin(); bool FreeTypeFaceWrapper::IsCharachterCodeAdobeStandard(FT_ULong inCharacterCode); bool FreeTypeFaceWrapper::IsScript(); bool FreeTypeFaceWrapper::IsItalic(); bool FreeTypeFaceWrapper::IsForceBold(); std::string FreeTypeFaceWrapper::GetPostscriptName(); std::string FreeTypeFaceWrapper::GetGlyphName(unsigned int inGlyphIndex); EStatusCode FreeTypeFaceWrapper::GetGlyphsForUnicodeText(const ULongList& inUnicodeCharacters,UIntList& outGlyphs); EStatusCode FreeTypeFaceWrapper::GetGlyphsForUnicodeText(const ULongListList& inUnicodeCharacters,UIntListList& outGlyphs); IWrittenFont* FreeTypeFaceWrapper::CreateWrittenFontObject(ObjectsContext* inObjectsContext); const std::string& FreeTypeFaceWrapper::GetFontFilePath(); long FreeTypeFaceWrapper::GetFontIndex(); FT_Short FreeTypeFaceWrapper::GetInPDFMeasurements(FT_Short inFontMeasurement); FT_UShort FreeTypeFaceWrapper::GetInPDFMeasurements(FT_UShort inFontMeasurement); FT_Pos FreeTypeFaceWrapper::GetInPDFMeasurements(FT_Pos inFontMeasurement); FT_Pos FreeTypeFaceWrapper::GetGlyphWidth(unsigned int inGlyphIndex); unsigned int FreeTypeFaceWrapper::GetGlyphIndexInFreeTypeIndexes(unsigned int inGlyphIndex); bool FreeTypeFaceWrapper::GetGlyphOutline(unsigned int inGlyphIndex, FreeTypeFaceWrapper::IOutlineEnumerator& inEnumerator); FT_Error FreeTypeFaceWrapper::LoadGlyph(FT_UInt inGlyphIndex, FT_Int32 inFlags); int FreeTypeFaceWrapper::IOutlineEnumerator::outline_moveto(const FT_Vector* to, void *closure); int FreeTypeFaceWrapper::IOutlineEnumerator::outline_lineto(const FT_Vector* to, void *closure); int FreeTypeFaceWrapper::IOutlineEnumerator::outline_conicto(const FT_Vector *control, const FT_Vector *to, void *closure); void FreeTypeFaceWrapper::IOutlineEnumerator::FTBegin(FT_UShort upm); bool FreeTypeFaceWrapper::IOutlineEnumerator::FTMoveto(const FT_Vector* to); bool FreeTypeFaceWrapper::IOutlineEnumerator::FTLineto(const FT_Vector* to); static inline FT_Pos ftround(double x); bool FreeTypeFaceWrapper::IOutlineEnumerator::FTConicto(const FT_Vector *control, const FT_Vector *to); bool FreeTypeFaceWrapper::IOutlineEnumerator::FTCubicto(const FT_Vector *control1, const FT_Vector *control2, const FT_Vector *to); void FreeTypeFaceWrapper::IOutlineEnumerator::FTEnd();

15263ea4a6da732328527af27889ad77915cb93249f0c2356f2a05a5fa7fc318

JeremiasE

KFormula

kspread/Style.cpp

Style::setFontUnderline

void Style::setFontUnderline( bool enabled ) { insertSubStyle( FontUnderline, enabled ); }

static uint calculateValue( QPen const & pen ); QString SubStyleOne<Style::CurrencyFormat, Currency>::debugData( bool withName ); QString SubStyle::name( Style::Key key ); Style::Style(); Style::Style( const Style& style ); Style::~Style(); Style::StyleType Style::type(); QString Style::parentName(); void Style::setParentName( const QString& name ); void Style::clearAttribute( Key key ); bool Style::hasAttribute( Key key ); void Style::loadAttributes( const QList<SharedSubStyle>& subStyles ); void Style::loadOdfDataStyle( KoOdfStylesReader& stylesReader, const KoXmlElement& element ); void Style::loadOdfParagraphProperties( KoOdfStylesReader& stylesReader, const KoStyleStack& styleStack ); void Style::loadOdfTableCellProperties( KoOdfStylesReader& stylesReader, const KoStyleStack& styleStack ); void Style::loadOdfTextProperties( KoOdfStylesReader& stylesReader, const KoStyleStack& styleStack ); static QString convertDateFormat( const QString& date ); Format::Type Style::dateType( const QString &_format ); Format::Type Style::timeType( const QString &_format ); Format::Type Style::fractionType( const QString &_format ); QString Style::saveOdfBackgroundStyle( KoGenStyles &mainStyles, const QBrush &brush ); void Style::saveXML(QDomDocument& doc, QDomElement& format, const StyleManager* styleManager); bool Style::loadXML(KoXmlElement& format, Paste::Mode mode); uint Style::bottomPenValue(); uint Style::rightPenValue(); uint Style::leftPenValue(); uint Style::topPenValue(); QColor Style::fontColor(); QColor Style::backgroundColor(); QPen Style::rightBorderPen(); QPen Style::bottomBorderPen(); QPen Style::leftBorderPen(); QPen Style::topBorderPen(); QPen Style::fallDiagonalPen(); QPen Style::goUpDiagonalPen(); QBrush Style::backgroundBrush(); QString Style::customFormat(); QString Style::prefix(); QString Style::postfix(); QString Style::fontFamily(); Style::HAlign Style::halign(); Style::VAlign Style::valign(); Style::FloatFormat Style::floatFormat(); Style::FloatColor Style::floatColor(); Format::Type Style::formatType(); Currency Style::currency(); QFont Style::font(); bool Style::bold(); bool Style::italic(); bool Style::underline(); bool Style::strikeOut(); int Style::fontSize(); int Style::precision(); int Style::angle(); double Style::indentation(); bool Style::verticalText(); bool Style::wrapText(); bool Style::printText(); bool Style::hideAll(); bool Style::hideFormula(); bool Style::notProtected(); bool Style::isDefault(); bool Style::isEmpty(); void Style::setHAlign( HAlign align ); void Style::setVAlign( VAlign align ); void Style::setFont( QFont const & font ); void Style::setFontFamily( QString const & family ); void Style::setFontBold( bool enabled ); void Style::setFontItalic( bool enabled ); void Style::setFontStrikeOut( bool enabled ); void Style::setFontSize( int size ); void Style::setFontColor( QColor const & color ); void Style::setBackgroundColor( QColor const & color ); void Style::setRightBorderPen( QPen const & pen ); void Style::setBottomBorderPen( QPen const & pen ); void Style::setLeftBorderPen( QPen const & pen ); void Style::setTopBorderPen( QPen const & pen ); void Style::setFallDiagonalPen( QPen const & pen ); void Style::setGoUpDiagonalPen( QPen const & pen ); void Style::setAngle( int angle ); void Style::setIndentation( double indent ); void Style::setBackgroundBrush( QBrush const & brush ); void Style::setFloatFormat( FloatFormat format ); void Style::setFloatColor( FloatColor color ); void Style::setFormatType( Format::Type format ); void Style::setCustomFormat( QString const & strFormat ); void Style::setPrecision( int precision ); void Style::setPrefix( QString const & prefix ); void Style::setPostfix( QString const & postfix ); void Style::setCurrency( Currency const & currency ); void Style::setWrapText( bool enable ); void Style::setHideAll( bool enable ); void Style::setHideFormula( bool enable ); void Style::setNotProtected( bool enable ); void Style::setDontPrintText( bool enable ); void Style::setVerticalText( bool enable ); void Style::setDefault(); void Style::clear(); QString Style::colorName( const QColor& color ); bool Style::compare( const SubStyle* one, const SubStyle* two ); bool Style::operator==( const Style& other ); void Style::operator=( const Style& other ); Style Style::operator-(const Style& other); void Style::merge( const Style& style ); QSet<Style::Key> Style::difference(const Style& other); void Style::dump(); QList<SharedSubStyle> Style::subStyles(); SharedSubStyle Style::createSubStyle( Key key, const QVariant& value ); void Style::insertSubStyle( Key key, const QVariant& value ); void Style::insertSubStyle( const SharedSubStyle& subStyle ); bool Style::releaseSubStyle( Key key ); CustomStyle::CustomStyle(); CustomStyle::CustomStyle( QString const & name, CustomStyle * parent ); CustomStyle::~CustomStyle(); Style::StyleType CustomStyle::type(); void CustomStyle::setType( StyleType type ); const QString& CustomStyle::name(); void CustomStyle::setName( QString const & name ); void CustomStyle::save(QDomDocument& doc, QDomElement& styles, const StyleManager* styleManager); bool CustomStyle::loadXML( KoXmlElement const & style, QString const & name ); int CustomStyle::usage();

124f02b16633c53d2a7bbd4ad467e1744734e9dd4b83c1ebf014c979a24ec229

einon

affymetrix-power-tools

sdk/file/TsvFile/TsvFile.cpp

void affx::TsvFile::clearIndexes

void affx::TsvFile::clearIndexes() { for (unsigned int i=0;i<m_index_vec.size();i++) { if (m_index_vec[i]!=NULL) { m_index_vec[i]->clear(); delete m_index_vec[i]; } } }

std::string affx::tolower(const string& str); affx::TsvFileBinding::TsvFileBinding(); affx::TsvFileBinding::~TsvFileBinding(); affx::TsvFileField::TsvFileField(); affx::TsvFileField::~TsvFileField(); affx::TsvFileIndex::TsvFileIndex(); affx::TsvFileIndex::~TsvFileIndex(); affx::TsvFileHeaderLine::TsvFileHeaderLine(); affx::TsvFileHeaderLine::TsvFileHeaderLine(const std::string& key,const std::string& value,int order); affx::TsvFile::TsvFile(); affx::TsvFile::TsvFile(const std::string& filename); affx::TsvFile::TsvFile(const affx::TsvFile& that); affx::TsvFile::~TsvFile(); int affx::TsvFile::defineColumn(int clvl,int cidx,const std::string& cname); std::fstream::pos_type affx::TsvFile::line_fpos(); int affx::TsvFile::countTotalDataLines(); void affx::TsvFile::currentLineAsString(std::string& line); affx::tsv_type_t TsvFile::stringToColType(const std::string& str); int TsvFile::getLineCountInFile(const std::string& filename, bool abortOnError); int TsvFile::replaceCharInFile(const std::string& filename, char a, char b, bool abortOnError );

aca5fb0923ca8ed92d0d47c572817d657dea45e4b64043e7132a794fb1f747e2

Frank-74

project64

Source/Project64-core/Settings/SettingType/SettingsType-Cheats.cpp

CSettingTypeCheats::Load

bool CSettingTypeCheats::Load (uint32_t Index, std::string & Value ) const { if (m_CheatIniFile == NULL) { return false; } stdstr_f Key("Cheat%d%s",Index,m_PostFix); return m_CheatIniFile->GetString(m_SectionIdent->c_str(),Key.c_str(),"",Value); }

CSettingTypeCheats::CSettingTypeCheats(const char * PostFix ); CSettingTypeCheats::~CSettingTypeCheats ( void ); void CSettingTypeCheats::Initialize ( void ); void CSettingTypeCheats::CleanUp ( void ); void CSettingTypeCheats::FlushChanges( void ); void CSettingTypeCheats::GameChanged ( void * /*Data */ ); bool CSettingTypeCheats::IsSettingSet(void); bool CSettingTypeCheats::Load (uint32_t /*Index*/, bool & /*Value*/ ); bool CSettingTypeCheats::Load (uint32_t /*Index*/, uint32_t & /*Value*/ ); void CSettingTypeCheats::LoadDefault (uint32_t /*Index*/, bool & /*Value*/ ); void CSettingTypeCheats::LoadDefault (uint32_t /*Index*/, uint32_t & /*Value*/ ); void CSettingTypeCheats::LoadDefault (uint32_t /*Index*/, std::string & /*Value*/ ); void CSettingTypeCheats::Save (uint32_t /*Index*/, bool /*Value*/ ); void CSettingTypeCheats::Save (uint32_t /*Index*/, uint32_t /*Value*/ ); void CSettingTypeCheats::Save (uint32_t Index, const std::string & Value ); void CSettingTypeCheats::Save (uint32_t Index, const char * Value ); void CSettingTypeCheats::Delete (uint32_t Index );

c4ec331de29de5ffd320fecea53d6d935ee78df66b65765acab62d68e3e1b826

fubendong2

kaiyuancoind

src/qt/bitcoingui.cpp

BitcoinGUI::BitcoinGUI

BitcoinGUI::BitcoinGUI(QWidget *parent): QMainWindow(parent), clientModel(0), walletModel(0), encryptWalletAction(0), changePassphraseAction(0), aboutQtAction(0), trayIcon(0), notificator(0), rpcConsole(0) { resize(850, 550); setWindowTitle(tr("Kaiyuancoin") + " - " + tr("Wallet")); #ifndef Q_WS_MAC qApp->setWindowIcon(QIcon(":icons/bitcoin")); setWindowIcon(QIcon(":icons/bitcoin")); #else setUnifiedTitleAndToolBarOnMac(true); QApplication::setAttribute(Qt::AA_DontShowIconsInMenus); #endif setAcceptDrops(true); createActions(); createMenuBar(); createToolBars(); createTrayIcon(); overviewPage = new OverviewPage(); miningPage = new MiningPage(this); transactionsPage = new QWidget(this); QVBoxLayout *vbox = new QVBoxLayout(); transactionView = new TransactionView(this); vbox->addWidget(transactionView); transactionsPage->setLayout(vbox); addressBookPage = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::SendingTab); receiveCoinsPage = new AddressBookPage(AddressBookPage::ForEditing, AddressBookPage::ReceivingTab); sendCoinsPage = new SendCoinsDialog(this); signVerifyMessageDialog = new SignVerifyMessageDialog(this); centralWidget = new QStackedWidget(this); centralWidget->addWidget(overviewPage); centralWidget->addWidget(miningPage); centralWidget->addWidget(transactionsPage); centralWidget->addWidget(addressBookPage); centralWidget->addWidget(receiveCoinsPage); centralWidget->addWidget(sendCoinsPage); #ifdef FIRST_CLASS_MESSAGING centralWidget->addWidget(signVerifyMessageDialog); #endif setCentralWidget(centralWidget); statusBar(); QFrame *frameBlocks = new QFrame(); frameBlocks->setContentsMargins(0,0,0,0); frameBlocks->setMinimumWidth(73); frameBlocks->setMaximumWidth(73); QHBoxLayout *frameBlocksLayout = new QHBoxLayout(frameBlocks); frameBlocksLayout->setContentsMargins(3,0,3,0); frameBlocksLayout->setSpacing(3); labelEncryptionIcon = new QLabel(); labelMiningIcon = new QLabel(); labelConnectionsIcon = new QLabel(); labelBlocksIcon = new QLabel(); frameBlocksLayout->addStretch(); frameBlocksLayout->addWidget(labelEncryptionIcon); frameBlocksLayout->addStretch(); frameBlocksLayout->addWidget(labelMiningIcon); frameBlocksLayout->addStretch(); frameBlocksLayout->addWidget(labelConnectionsIcon); frameBlocksLayout->addStretch(); frameBlocksLayout->addWidget(labelBlocksIcon); frameBlocksLayout->addStretch(); progressBarLabel = new QLabel(); progressBarLabel->setVisible(false); progressBar = new QProgressBar(); progressBar->setAlignment(Qt::AlignCenter); progressBar->setVisible(false); statusBar()->addWidget(progressBarLabel); statusBar()->addWidget(progressBar); statusBar()->addPermanentWidget(frameBlocks); syncIconMovie = new QMovie(":/movies/update_spinner", "mng", this); connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), this, SLOT(gotoHistoryPage())); connect(overviewPage, SIGNAL(transactionClicked(QModelIndex)), transactionView, SLOT(focusTransaction(QModelIndex))); connect(transactionView, SIGNAL(doubleClicked(QModelIndex)), transactionView, SLOT(showDetails())); rpcConsole = new RPCConsole(this); connect(openRPCConsoleAction, SIGNAL(triggered()), rpcConsole, SLOT(show())); connect(addressBookPage, SIGNAL(verifyMessage(QString)), this, SLOT(gotoVerifyMessageTab(QString))); connect(receiveCoinsPage, SIGNAL(signMessage(QString)), this, SLOT(gotoSignMessageTab(QString))); gotoOverviewPage(); }

BitcoinGUI::~BitcoinGUI(); void BitcoinGUI::createActions(); void BitcoinGUI::createMenuBar(); void BitcoinGUI::createToolBars(); void BitcoinGUI::setClientModel(ClientModel *clientModel); void BitcoinGUI::setWalletModel(WalletModel *walletModel); void BitcoinGUI::createTrayIcon(); void BitcoinGUI::trayIconActivated(QSystemTrayIcon::ActivationReason reason); void BitcoinGUI::optionsClicked(); void BitcoinGUI::aboutClicked(); void BitcoinGUI::setNumConnections(int count); void BitcoinGUI::setNumBlocks(int count, int nTotalBlocks); void BitcoinGUI::setMining(bool mining, int hashrate); void BitcoinGUI::error(const QString &title, const QString &message, bool modal); void BitcoinGUI::changeEvent(QEvent *e); void BitcoinGUI::closeEvent(QCloseEvent *event); void BitcoinGUI::askFee(qint64 nFeeRequired, bool *payFee); void BitcoinGUI::incomingTransaction(const QModelIndex & parent, int start, int end); void BitcoinGUI::gotoOverviewPage(); void BitcoinGUI::gotoMiningPage(); void BitcoinGUI::gotoHistoryPage(); void BitcoinGUI::gotoAddressBookPage(); void BitcoinGUI::gotoReceiveCoinsPage(); void BitcoinGUI::gotoSendCoinsPage(); void BitcoinGUI::gotoSignMessageTab(QString addr); void BitcoinGUI::gotoVerifyMessageTab(QString addr); void BitcoinGUI::dragEnterEvent(QDragEnterEvent *event); void BitcoinGUI::dropEvent(QDropEvent *event); void BitcoinGUI::handleURI(QString strURI); void BitcoinGUI::setEncryptionStatus(int status); void BitcoinGUI::encryptWallet(bool status); void BitcoinGUI::backupWallet(); void BitcoinGUI::changePassphrase(); void BitcoinGUI::unlockWallet(); void BitcoinGUI::showNormalIfMinimized(bool fToggleHidden); void BitcoinGUI::toggleHidden();

4e48151a698eff7614c37787976d6d60181f62ad0d62ca7d634610ec17ef6029

djkabala

KabalaEngine

Source/Builder/UserInterface/MainWindow/HelpPanel/KEHelpPanel.cpp

HelpPanel::changed

void HelpPanel::changed(ConstFieldMaskArg whichField, UInt32 origin, BitVector details) { Inherited::changed(whichField, origin, details); }

void HelpPanel::createInterface(ApplicationBuilder* const TheApplicationBuilder); void HelpPanel::destroyInterface(ApplicationBuilder* const TheApplicationBuilder); void HelpPanel::attachInterface(ApplicationBuilder* const TheApplicationBuilder); void HelpPanel::dettachInterface(ApplicationBuilder* const TheApplicationBuilder); HelpPanel::HelpPanel(void); HelpPanel::HelpPanel(const HelpPanel &source); HelpPanel::~HelpPanel(void);

c74b2b8ef13d951872123b4a012eecc24357c637bed1a0710e483a523ca3ee9a

LibrePCB

LibrePCB

libs/librepcb/editor/utils/standardeditorcommandhandler.cpp

StandardEditorCommandHandler::shortcutsReference

void StandardEditorCommandHandler::shortcutsReference() const noexcept { try { mParent->setCursor(Qt::WaitCursor); auto cursorScopeGuard = scopeGuard( [this]() { QTimer::singleShot(1000, mParent, &QWidget::unsetCursor); }); FilePath fp = FilePath::getApplicationTempPath().getPathTo( "librepcb-shortcuts-reference.pdf"); ShortcutsReferenceGenerator generator(EditorCommandSet::instance()); generator.generatePdf(fp); DesktopServices ds(mSettings, mParent); ds.openLocalPath(fp); } catch (const Exception& e) { QMessageBox::critical(mParent, tr("Error"), e.getMsg()); } }

StandardEditorCommandHandler::~StandardEditorCommandHandler(); void StandardEditorCommandHandler::aboutLibrePcb(); void StandardEditorCommandHandler::onlineDocumentation(); void StandardEditorCommandHandler::website(); void StandardEditorCommandHandler::fileManager(const FilePath& fp);

72e550cc9ec84c20e311ad3387462b65b80b0cd7879f73ea4deaec83d474b06e

3nids

QGIS

src/core/qgsfontutils.cpp

QgsFontUtils::translateNamedStyle

QString QgsFontUtils::translateNamedStyle( const QString &namedStyle ) { #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0) QStringList words = namedStyle.split( ' ', QString::SkipEmptyParts ); #else QStringList words = namedStyle.split( ' ', Qt::SkipEmptyParts ); #endif for ( int i = 0, n = words.length(); i < n; ++i ) { words[i] = QCoreApplication::translate( "QFontDatabase", words[i].toLocal8Bit().constData() ); } return words.join( QLatin1Char( ' ' ) ); }

bool QgsFontUtils::fontMatchOnSystem( const QFont &f ); bool QgsFontUtils::fontFamilyOnSystem( const QString &family ); bool QgsFontUtils::fontFamilyHasStyle( const QString &family, const QString &style ); QString QgsFontUtils::resolveFontStyleName( const QFont &font ); bool QgsFontUtils::fontFamilyMatchOnSystem( const QString &family, QString *chosen, bool *match ); bool QgsFontUtils::updateFontViaStyle( QFont &f, const QString &fontstyle, bool fallback ); QString QgsFontUtils::standardTestFontFamily(); bool QgsFontUtils::loadStandardTestFonts( const QStringList &loadstyles ); QFont QgsFontUtils::getStandardTestFont( const QString &style, int pointsize ); QDomElement QgsFontUtils::toXmlElement( const QFont &font, QDomDocument &document, const QString &elementName ); bool QgsFontUtils::setFromXmlElement( QFont &font, const QDomElement &element ); bool QgsFontUtils::setFromXmlChildNode( QFont &font, const QDomElement &element, const QString &childNode ); QMimeData *QgsFontUtils::toMimeData( const QFont &font ); QFont QgsFontUtils::fromMimeData( const QMimeData *data, bool *ok ); static QMap<QString, QString> createTranslatedStyleMap(); QString QgsFontUtils::untranslateNamedStyle( const QString &namedStyle ); QString QgsFontUtils::asCSS( const QFont &font, double pointToPixelScale ); void QgsFontUtils::addRecentFontFamily( const QString &family ); QStringList QgsFontUtils::recentFontFamilies();

6e7fa2a5cfa71a9bc6731f3ffc7229af1bb54a3a48594846f02b92086e41940c

kmatheussen

radium

audio/faust-examples/faust-stk/flute.cpp

init

void init(int samplingFreq) { fSamplingFreq = samplingFreq; for (int i=0; i<2; i++) iRec17[i] = 0; }

void fill (int count, float output[]); static void metadata(Meta* m); static void classInit(int samplingFreq); virtual void instanceInit(int samplingFreq); virtual void init(int samplingFreq); virtual void buildUserInterface(UI* interface); virtual void compute (int count, FAUSTFLOAT** input, FAUSTFLOAT** output);

545b426ea56a9fd666a06eefc5d7fcfc4f6e6174fb836b0e5847f7781f8e2580

andrlee

vkplayer

src/plugin/vkontakte/vkontakteconnection.cpp

VKontakteConnection::accessToken

QString VKontakteConnection::accessToken() const { return m_accessToken; }

VKontakteConnection::VKontakteConnection(QObject *parent); VKontakteConnection::~VKontakteConnection(); QString VKontakteConnection::clientId(); void VKontakteConnection::setClientId(const QString &clientId); QString VKontakteConnection::userId(); void VKontakteConnection::setUserId(const QString &userId); void VKontakteConnection::setAccessToken (const QString &accessToken); QStringList VKontakteConnection::permissions(); void VKontakteConnection::setPermissions(const QStringList &permissions); bool VKontakteConnection::isAuthorized(); bool VKontakteConnection::sessionValidated(); VKontakteConnection::State VKontakteConnection::state(); void VKontakteConnection::setState(State state); void VKontakteConnection::setWebInterfaceActive(const bool active); bool VKontakteConnection::authenticate(); bool VKontakteConnection::deauthenticate(); void VKontakteConnection::onUrlChanged(const QUrl &url); void VKontakteConnection::authorize(const QString &accessToken, const QString &userId); void VKontakteConnection::checkAuthenticationUrl(const QUrl &url); int VKontakteConnection::checkReplyErrors(QNetworkReply* reply); void VKontakteConnection::checkVKConnectionErrors(const QByteArray& reply); bool VKontakteConnection::postMessage(const QVariantMap &message); bool VKontakteConnection::retrieveMessageCount(); bool VKontakteConnection::retrieveMessages(const QString &from, const QString &to, int max); void VKontakteConnection::cancel(); void VKontakteConnection::replyFinished(QNetworkReply* reply); bool VKontakteConnection::storeCredentials(); bool VKontakteConnection::restoreCredentials(); bool VKontakteConnection::removeCredentials(); bool VKontakteConnection::saveAudioTrack(const QUrl& url); bool VKontakteConnection::loadMusic(int count); bool VKontakteConnection::search(const QString& text, int count); bool VKontakteConnection::addMusic(const QString& aid, const QString& oid); bool VKontakteConnection::deleteMusic(const QString& aid); bool VKontakteConnection::loadVideos(int count); bool VKontakteConnection::searchVideo(const QString& text, int count); bool VKontakteConnection::addVideo(const QString& vid, const QString& oid); bool VKontakteConnection::deleteVideo(const QString& vid);

e844f1ff95c75101985704db8fd8865a0d074d0dea1e532da56f4578ac2618fc

chriskmanx

qmole

QMOLEDEV/fox-1.6.49/src/FXString.cpp

FXString::length

void FXString::length(FXint len){ if(*(((FXint*)str)-1)!=len){ if(0<len){ if(str==EMPTY) str=sizeof(FXint)+(FXchar*)malloc(ROUNDUP(1+len)+sizeof(FXint)); else str=sizeof(FXint)+(FXchar*)realloc(str-sizeof(FXint),ROUNDUP(1+len)+sizeof(FXint)); str[len]=0; *(((FXint*)str)-1)=len; } else if(str!=EMPTY){ free(str-sizeof(FXint)); str=EMPTY; } } }

static inline FXint strlen(const FXchar *src); static inline FXint strlen(const FXwchar *src); static inline FXint strlen(const FXnchar *src); FXwchar wc(const FXchar *ptr); FXwchar wc(const FXnchar *ptr); FXint wclen(const FXchar *ptr); FXint wclen(const FXnchar *ptr); FXint wcvalidate(const FXchar* string,FXint pos); FXint wcvalidate(const FXnchar *string,FXint pos); FXint wcinc(const FXchar* string,FXint pos); FXint wcinc(const FXnchar *string,FXint pos); FXint wcdec(const FXchar* string,FXint pos); FXint wcdec(const FXnchar *string,FXint pos); bool isutfvalid(const FXchar* str); FXint utfslen(const FXwchar *str,FXint n); FXint utfslen(const FXwchar *str); FXint utfslen(const FXnchar *str,FXint n); FXint utfslen(const FXnchar *str); FXint wcslen(const FXchar *str,FXint n); FXint wcslen(const FXchar *str); FXint ncslen(const FXchar *str,FXint n); FXint ncslen(const FXchar *str); FXint utf2wcs(FXwchar *dst,const FXchar *src,FXint n); FXint utf2wcs(FXwchar *dst,const FXchar *src); FXint utf2ncs(FXnchar *dst,const FXchar *src,FXint n); FXint utf2ncs(FXnchar *dst,const FXchar *src); FXint wc2utfs(FXchar* dst,const FXwchar *src,FXint n); FXint wc2utfs(FXchar* dst,const FXwchar *src); FXint nc2utfs(FXchar* dst,const FXnchar *src,FXint n); FXint nc2utfs(FXchar* dst,const FXnchar *src); FXwchar FXString::wc(FXint i); FXint FXString::count(FXint pos,FXint len); FXint FXString::count(); FXint FXString::index(FXint offs); FXint FXString::offset(FXint indx); FXString::FXString(); FXString::FXString(const FXString& s); FXString::FXString(const FXchar* s); FXString::FXString(const FXwchar* s); FXString::FXString(const FXnchar* s); FXString::FXString(const FXchar* s,FXint n); FXString::FXString(const FXwchar* s,FXint m); FXString::FXString(const FXnchar* s,FXint m); FXString::FXString(FXchar c,FXint n); FXString FXString::section(FXchar delim,FXint start,FXint num); FXString FXString::section(const FXchar* delim,FXint n,FXint start,FXint num); FXString FXString::section(const FXchar* delim,FXint start,FXint num); FXString FXString::section(const FXString& delim,FXint start,FXint num); FXString& FXString::adopt(FXString& s); FXString& FXString::assign(FXchar c); FXString& FXString::assign(FXchar c,FXint n); FXString& FXString::assign(const FXchar* s,FXint n); FXString& FXString::assign(const FXwchar* s,FXint m); FXString& FXString::assign(const FXnchar* s,FXint m); FXString& FXString::assign(const FXchar* s); FXString& FXString::assign(const FXwchar* s); FXString& FXString::assign(const FXnchar* s); FXString& FXString::assign(const FXString& s); FXString& FXString::operator=(const FXchar* s); FXString& FXString::operator=(const FXwchar* s); FXString& FXString::operator=(const FXnchar* s); FXString& FXString::operator=(const FXString& s); FXString& FXString::insert(FXint pos,FXchar c); FXString& FXString::insert(FXint pos,FXchar c,FXint n); FXString& FXString::insert(FXint pos,const FXchar* s,FXint n); FXString& FXString::insert(FXint pos,const FXwchar* s,FXint m); FXString& FXString::insert(FXint pos,const FXnchar* s,FXint m); FXString& FXString::insert(FXint pos,const FXchar* s); FXString& FXString::insert(FXint pos,const FXwchar* s); FXString& FXString::insert(FXint pos,const FXnchar* s); FXString& FXString::insert(FXint pos,const FXString& s); FXString& FXString::append(FXchar c); FXString& FXString::append(FXchar c,FXint n); FXString& FXString::append(const FXchar* s,FXint n); FXString& FXString::append(const FXwchar* s,FXint m); FXString& FXString::append(const FXnchar* s,FXint m); FXString& FXString::append(const FXchar* s); FXString& FXString::append(const FXwchar* s); FXString& FXString::append(const FXnchar* s); FXString& FXString::append(const FXString& s); FXString& FXString::operator+=(FXchar c); FXString& FXString::operator+=(const FXchar* s); FXString& FXString::operator+=(const FXwchar* s); FXString& FXString::operator+=(const FXnchar* s); FXString& FXString::operator+=(const FXString& s); FXString& FXString::prepend(FXchar c); FXString& FXString::prepend(FXchar c,FXint n); FXString& FXString::prepend(const FXchar* s,FXint n); FXString& FXString::prepend(const FXwchar* s,FXint m); FXString& FXString::prepend(const FXnchar* s,FXint m); FXString& FXString::prepend(const FXchar* s); FXString& FXString::prepend(const FXwchar* s); FXString& FXString::prepend(const FXnchar* s); FXString& FXString::prepend(const FXString& s); FXString& FXString::replace(FXint pos,FXchar c); FXString& FXString::replace(FXint pos,FXint m,FXchar c,FXint n); FXString& FXString::replace(FXint pos,FXint m,const FXchar* s,FXint n); FXString& FXString::replace(FXint pos,FXint m,const FXwchar* s,FXint n); FXString& FXString::replace(FXint pos,FXint m,const FXnchar* s,FXint n); FXString& FXString::replace(FXint pos,FXint m,const FXchar* s); FXString& FXString::replace(FXint pos,FXint m,const FXwchar* s); FXString& FXString::replace(FXint pos,FXint m,const FXnchar* s); FXString& FXString::replace(FXint pos,FXint m,const FXString& s); FXString& FXString::move(FXint dst,FXint src,FXint n); FXString& FXString::erase(FXint pos); FXString& FXString::erase(FXint pos,FXint n); FXint FXString::contains(FXchar ch); FXint FXString::contains(const FXchar* sub,FXint n); FXint FXString::contains(const FXchar* sub); FXint FXString::contains(const FXString& sub); FXString operator+(const FXString& s1,const FXString& s2); FXString operator+(const FXString& s1,const FXchar* s2); FXString operator+(const FXString& s1,const FXwchar* s2); FXString operator+(const FXString& s1,const FXnchar* s2); FXString operator+(const FXchar* s1,const FXString& s2); FXString operator+(const FXwchar* s1,const FXString& s2); FXString operator+(const FXnchar* s1,const FXString& s2); FXString operator+(const FXString& s,FXchar c); FXString operator+(FXchar c,const FXString& s); FXString& FXString::substitute(FXchar org,FXchar sub,bool all); FXString& FXString::substitute(const FXchar* org,FXint olen,const FXchar* rep,FXint rlen,bool all); FXString& FXString::substitute(const FXchar* org,const FXchar* rep,bool all); FXString& FXString::substitute(const FXString& org,const FXString& rep,bool all); FXString& FXString::simplify(); FXString& FXString::trim(); FXString& FXString::trimBegin(); FXString& FXString::trimEnd(); FXString& FXString::trunc(FXint pos); FXString& FXString::clear(); FXString FXString::left(FXint n); FXString FXString::right(FXint n); FXString FXString::mid(FXint pos,FXint n); FXString FXString::before(FXchar c,FXint n); FXString FXString::rbefore(FXchar c,FXint n); FXString FXString::after(FXchar c,FXint n); FXString FXString::rafter(FXchar c,FXint n); FXString& FXString::lower(); FXString& FXString::upper(); FXint compare(const FXchar* s1,const FXchar* s2); FXint compare(const FXchar* s1,const FXString& s2); FXint compare(const FXString& s1,const FXchar* s2); FXint compare(const FXString& s1,const FXString& s2); FXint compare(const FXchar* s1,const FXchar* s2,FXint n); FXint compare(const FXchar* s1,const FXString& s2,FXint n); FXint compare(const FXString& s1,const FXchar* s2,FXint n); FXint compare(const FXString& s1,const FXString& s2,FXint n); FXint comparecase(const FXchar* s1,const FXchar* s2); FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n); FXint comparecase(const FXchar* s1,const FXchar* s2); FXint comparecase(const FXchar* s1,const FXString& s2); FXint comparecase(const FXString& s1,const FXchar* s2); FXint comparecase(const FXString& s1,const FXString& s2); FXint comparecase(const FXchar* s1,const FXchar* s2,FXint n); FXint comparecase(const FXchar* s1,const FXString& s2,FXint n); FXint comparecase(const FXString& s1,const FXchar* s2,FXint n); FXint comparecase(const FXString& s1,const FXString& s2,FXint n); bool operator==(const FXString& s1,const FXString& s2); bool operator==(const FXString& s1,const FXchar* s2); bool operator==(const FXchar* s1,const FXString& s2); bool operator!=(const FXString& s1,const FXString& s2); bool operator!=(const FXString& s1,const FXchar* s2); bool operator!=(const FXchar* s1,const FXString& s2); bool operator<(const FXString& s1,const FXString& s2); bool operator<(const FXString& s1,const FXchar* s2); bool operator<(const FXchar* s1,const FXString& s2); bool operator<=(const FXString& s1,const FXString& s2); bool operator<=(const FXString& s1,const FXchar* s2); bool operator<=(const FXchar* s1,const FXString& s2); bool operator>(const FXString& s1,const FXString& s2); bool operator>(const FXString& s1,const FXchar* s2); bool operator>(const FXchar* s1,const FXString& s2); bool operator>=(const FXString& s1,const FXString& s2); bool operator>=(const FXString& s1,const FXchar* s2); bool operator>=(const FXchar* s1,const FXString& s2); FXint FXString::find(FXchar c,FXint pos,FXint n); FXint FXString::rfind(FXchar c,FXint pos,FXint n); FXint FXString::find(FXchar c,FXint pos); FXint FXString::rfind(FXchar c,FXint pos); FXint FXString::find(const FXchar* substr,FXint n,FXint pos); FXint FXString::find(const FXchar* substr,FXint pos); FXint FXString::find(const FXString& substr,FXint pos); FXint FXString::rfind(const FXchar* substr,FXint n,FXint pos); FXint FXString::rfind(const FXchar* substr,FXint pos); FXint FXString::rfind(const FXString& substr,FXint pos); FXint FXString::find_first_of(const FXchar* set,FXint n,FXint pos); FXint FXString::find_first_of(const FXchar* set,FXint pos); FXint FXString::find_first_of(const FXString& set,FXint pos); FXint FXString::find_first_of(FXchar c,FXint pos); FXint FXString::find_last_of(const FXchar* set,FXint n,FXint pos); FXint FXString::find_last_of(const FXchar* set,FXint pos); FXint FXString::find_last_of(const FXString& set,FXint pos); FXint FXString::find_last_of(FXchar c,FXint pos); FXint FXString::find_first_not_of(const FXchar* set,FXint n,FXint pos); FXint FXString::find_first_not_of(const FXchar* set,FXint pos); FXint FXString::find_first_not_of(const FXString& set,FXint pos); FXint FXString::find_first_not_of(FXchar c,FXint pos); FXint FXString::find_last_not_of(const FXchar* set,FXint n,FXint pos); FXint FXString::find_last_not_of(const FXchar* set,FXint pos); FXint FXString::find_last_not_of(const FXString& set,FXint pos); FXint FXString::find_last_not_of(FXchar c,FXint pos); FXuint FXString::hash(); FXStream& operator<<(FXStream& store,const FXString& s); FXStream& operator>>(FXStream& store,FXString& s); FXString& FXString::vformat(const FXchar* fmt,va_list args); FXString& FXString::format(const FXchar* fmt,...); FXint FXString::vscan(const FXchar* fmt,va_list args); FXint FXString::scan(const FXchar* fmt,...); FXString FXStringVFormat(const FXchar* fmt,va_list args); FXString FXStringFormat(const FXchar* fmt,...); FXString FXStringVal(FXlong num,FXint base); FXString FXStringVal(FXulong num,FXint base); FXString FXStringVal(FXint num,FXint base); FXString FXStringVal(FXuint num,FXint base); FXString FXStringVal(FXfloat num,FXint prec,FXint exp); FXString FXStringVal(FXdouble num,FXint prec,FXint exp); FXlong FXLongVal(const FXString& s,FXint base); FXulong FXULongVal(const FXString& s,FXint base); FXint FXIntVal(const FXString& s,FXint base); FXuint FXUIntVal(const FXString& s,FXint base); FXfloat FXFloatVal(const FXString& s); FXdouble FXDoubleVal(const FXString& s); FXString fromAscii(const FXString& s); FXString toAscii(const FXString& s); FXString escape(const FXString& s); FXString unescape(const FXString& s); static FXint decomposehangul(FXwchar *result,FXwchar w); static FXint composehangul(FXwchar *result,FXint len); static FXint decomposerecursive(FXwchar *result,FXwchar w,FXuint kind); static FXwchar *normalize(FXwchar* result,FXint len); static FXint compose(FXwchar* result,FXint len); FXString normalize(const FXString& s); FXString decompose(const FXString& s,FXuint kind); FXString compose(const FXString& s,FXuint kind); FXint compareversion(const FXchar *s1,const FXchar *s2); FXint compareversion(const FXchar* s1,const FXString& s2); FXint compareversion(const FXString& s1,const FXchar* s2); FXint compareversion(const FXString& s1,const FXString& s2); FXString& unixToDos(FXString& str); FXString& dosToUnix(FXString& str); FXString::~FXString();

329dc97c44c15ad553b70514c713bbd7dc31b2d218eb35cd3d895f08a8c9e4f2

UniStuttgart-VISUS

megamol

plugins/protein_calls/src/MolecularDataCall.cpp

MolecularDataCall::SecStructure::operator==

bool MolecularDataCall::SecStructure::operator==(const MolecularDataCall::SecStructure& rhs) const { return ((this->aminoAcidCnt == rhs.aminoAcidCnt) && (this->firstAminoAcidIdx == rhs.firstAminoAcidIdx) && (this->type == rhs.type)); }

MolecularDataCall::Residue::Residue(void); MolecularDataCall::Residue::Residue(const MolecularDataCall::Residue& src); MolecularDataCall::Residue::~Residue(void); void MolecularDataCall::Residue::SetPosition(unsigned int firstAtom, unsigned int atomCnt); MolecularDataCall::Residue& MolecularDataCall::Residue::operator=(const MolecularDataCall::Residue& rhs); bool MolecularDataCall::Residue::operator==(const MolecularDataCall::Residue& rhs); MolecularDataCall::AminoAcid::AminoAcid(void); MolecularDataCall::AminoAcid::AminoAcid(const MolecularDataCall::AminoAcid& src); MolecularDataCall::AminoAcid::~AminoAcid(void); void MolecularDataCall::AminoAcid::SetCAlphaIndex(unsigned int idx); void MolecularDataCall::AminoAcid::SetCCarbIndex(unsigned int idx); void MolecularDataCall::AminoAcid::SetNIndex(unsigned int idx); void MolecularDataCall::AminoAcid::SetOIndex(unsigned int idx); MolecularDataCall::AminoAcid& MolecularDataCall::AminoAcid::operator=(const MolecularDataCall::AminoAcid& rhs); bool MolecularDataCall::AminoAcid::operator==(const MolecularDataCall::AminoAcid& rhs); MolecularDataCall::SecStructure::SecStructure(void); MolecularDataCall::SecStructure::SecStructure(const MolecularDataCall::SecStructure& src); MolecularDataCall::SecStructure::~SecStructure(void); void MolecularDataCall::SecStructure::SetPosition(unsigned int firstAminoAcidIdx, unsigned int aminoAcidCnt); void MolecularDataCall::SecStructure::SetType(MolecularDataCall::SecStructure::ElementType type); MolecularDataCall::AtomType::AtomType(void); MolecularDataCall::AtomType::AtomType(const AtomType& src); MolecularDataCall::AtomType& MolecularDataCall::AtomType::operator=(const MolecularDataCall::AtomType& rhs); bool MolecularDataCall::AtomType::operator==(const MolecularDataCall::AtomType& rhs); MolecularDataCall::Molecule::Molecule(void); MolecularDataCall::Molecule::Molecule(const MolecularDataCall::Molecule& src); MolecularDataCall::Molecule::Molecule(unsigned int firstResIdx, unsigned int resCnt, int chainIdx); MolecularDataCall::Molecule::~Molecule(void); MolecularDataCall::Molecule& MolecularDataCall::Molecule::operator=(const MolecularDataCall::Molecule& rhs); bool MolecularDataCall::Molecule::operator==(const MolecularDataCall::Molecule& rhs); MolecularDataCall::Chain::Chain(void); MolecularDataCall::Chain::Chain(const MolecularDataCall::Chain& src); MolecularDataCall::Chain::Chain(unsigned int firstMolIdx, unsigned int molCnt, char name, ChainType chainType); MolecularDataCall::Chain::~Chain(void); MolecularDataCall::Chain& MolecularDataCall::Chain::operator=(const MolecularDataCall::Chain& rhs); bool MolecularDataCall::Chain::operator==(const MolecularDataCall::Chain& rhs); MolecularDataCall::MolecularDataCall(void); void MolecularDataCall::SetResidues(unsigned int resCnt, const Residue** res); void MolecularDataCall::SetResidueTypeNames(unsigned int namesCnt, const vislib::StringA* names); void MolecularDataCall::SetConnections(unsigned int conCnt, const unsigned int* con); void MolecularDataCall::SetMolecules(unsigned int molCnt, const Molecule* mol); void MolecularDataCall::SetChains(unsigned int chainCnt, const Chain* chain); void MolecularDataCall::SetSecondaryStructureCount(unsigned int cnt); bool MolecularDataCall::SetSecondaryStructure(unsigned int idx, SecStructure secS); void MolecularDataCall::SetFilter(const int* atomFilter); const MolecularDataCall::SecStructure* MolecularDataCall::SecondaryStructures(); unsigned int MolecularDataCall::SecondaryStructureCount();

2ed862dced424c098419a5953f43519a8ddef3908bdc04aeed82c5e64b089ade

MECTsrl

mect_apps

TP1070_01_C/Monitoring/config/crosstable.cpp

int doWrite_TCP_DigOut_A_7

int doWrite_TCP_DigOut_A_7(int value) { return doWrite(ID_TCP_DigOut_A_7, &value); }

fb865b50ab3995f1117df4dd430109b9536f1f9b28ae80860f381654e50066b4

marcoscao

ak-cpp

ak_core/SqlSystem.cpp

SqlSystem::update_db

bool SqlSystem::update_db( std::string const & db_name, std::string const & sql_def_file ) { return true; }

SqlSystem::SqlSystem(); SqlSystem::~SqlSystem(); bool SqlSystem::open_db( std::string const & db_name ); bool SqlSystem::create_db( std::string const & db_name, std::string const & sql_def_file ); bool SqlSystem::exist_db( std::string const & db_name ); bool SqlSystem::search_for_updates(); bool SqlSystem::execute_sql( std::string const & db_name ); bool SqlSystem::exist_update_file_();

0a25ff1851475eda192719b50163e296301c6a5f905cb5ff420f690849079db6

jodogne

OrthancMirror

OrthancServer/Plugins/Samples/Common/OrthancPluginCppWrapper.cpp

MemoryBuffer::Check

void MemoryBuffer::Check(OrthancPluginErrorCode code) { if (code != OrthancPluginErrorCode_Success) { buffer_.data = NULL; buffer_.size = 0; ORTHANC_PLUGINS_THROW_PLUGIN_ERROR_CODE(code); } }

void SetGlobalContext(OrthancPluginContext* context); bool HasGlobalContext(); OrthancPluginContext* GetGlobalContext(); bool MemoryBuffer::CheckHttp(OrthancPluginErrorCode code); MemoryBuffer::MemoryBuffer(); MemoryBuffer::MemoryBuffer(const void* buffer, size_t size); void MemoryBuffer::Clear(); void MemoryBuffer::Assign(OrthancPluginMemoryBuffer& other); void MemoryBuffer::Swap(MemoryBuffer& other); OrthancPluginMemoryBuffer MemoryBuffer::Release(); void MemoryBuffer::ToString(std::string& target); void MemoryBuffer::ToJson(Json::Value& target); bool MemoryBuffer::RestApiGet(const std::string& uri, bool applyPlugins); bool ReadJson(Json::Value& target, const std::string& source); bool ReadJsonWithoutComments(Json::Value& target, const std::string& source); void WriteFastJson(std::string& target, const Json::Value& source); void WriteStyledJson(std::string& target, const Json::Value& source); void MemoryBuffer::CreateDicom(const Json::Value& tags, OrthancPluginCreateDicomFlags flags); void MemoryBuffer::ReadFile(const std::string& path); void MemoryBuffer::GetDicomQuery(const OrthancPluginWorklistQuery* query); void OrthancString::Assign(char* str); void OrthancString::Clear(); void OrthancString::ToString(std::string& target); void OrthancString::ToJson(Json::Value& target); void OrthancString::ToJsonWithoutComments(Json::Value& target); void MemoryBuffer::GetDicomInstance(const std::string& instanceId); void LogError(const std::string& message); void LogWarning(const std::string& message); void LogInfo(const std::string& message); void OrthancConfiguration::LoadConfiguration(); OrthancConfiguration::OrthancConfiguration(); OrthancConfiguration::OrthancConfiguration(bool loadConfiguration); std::string OrthancConfiguration::GetPath(const std::string& key); bool OrthancConfiguration::IsSection(const std::string& key); void OrthancConfiguration::GetSection(OrthancConfiguration& target, const std::string& key); bool OrthancConfiguration::LookupStringValue(std::string& target, const std::string& key); bool OrthancConfiguration::LookupIntegerValue(int& target, const std::string& key); bool OrthancConfiguration::LookupUnsignedIntegerValue(unsigned int& target, const std::string& key); bool OrthancConfiguration::LookupBooleanValue(bool& target, const std::string& key); bool OrthancConfiguration::LookupFloatValue(float& target, const std::string& key); std::string OrthancConfiguration::GetStringValue(const std::string& key, const std::string& defaultValue); int OrthancConfiguration::GetIntegerValue(const std::string& key, int defaultValue); unsigned int OrthancConfiguration::GetUnsignedIntegerValue(const std::string& key, unsigned int defaultValue); bool OrthancConfiguration::GetBooleanValue(const std::string& key, bool defaultValue); float OrthancConfiguration::GetFloatValue(const std::string& key, float defaultValue); void OrthancConfiguration::GetDictionary(std::map<std::string, std::string>& target, const std::string& key); void OrthancImage::Clear(); void OrthancImage::CheckImageAvailable(); OrthancImage::OrthancImage(); OrthancImage::OrthancImage(OrthancPluginImage* image); void OrthancImage::UncompressPngImage(const void* data, size_t size); void OrthancImage::UncompressJpegImage(const void* data, size_t size); OrthancPluginPixelFormat OrthancImage::GetPixelFormat(); unsigned int OrthancImage::GetWidth(); unsigned int OrthancImage::GetHeight(); unsigned int OrthancImage::GetPitch(); void* OrthancImage::GetBuffer(); void OrthancImage::CompressPngImage(MemoryBuffer& target); void OrthancImage::CompressJpegImage(MemoryBuffer& target, uint8_t quality); void OrthancImage::AnswerPngImage(OrthancPluginRestOutput* output); void OrthancImage::AnswerJpegImage(OrthancPluginRestOutput* output, uint8_t quality); OrthancPluginImage* OrthancImage::Release(); FindMatcher::FindMatcher(const OrthancPluginWorklistQuery* worklist); void FindMatcher::SetupDicom(const void* query, uint32_t size); FindMatcher::~FindMatcher(); bool FindMatcher::IsMatch(const void* dicom, uint32_t size); void AnswerJson(const Json::Value& value, OrthancPluginRestOutput* output); void AnswerHttpError(uint16_t httpError, OrthancPluginRestOutput *output); void AnswerMethodNotAllowed(OrthancPluginRestOutput *output, const char* allowedMethods); bool RestApiDelete(const std::string& uri, bool applyPlugins); const char* AutodetectMimeType(const std::string& path); size_t OrthancPeers::GetPeerIndex(const std::string& name); OrthancPeers::OrthancPeers(); OrthancPeers::~OrthancPeers(); bool OrthancPeers::LookupName(size_t& target, const std::string& name); std::string OrthancPeers::GetPeerName(size_t index); std::string OrthancPeers::GetPeerUrl(size_t index); std::string OrthancPeers::GetPeerUrl(const std::string& name); bool OrthancPeers::DoDelete(size_t index, const std::string& uri); bool OrthancPeers::DoDelete(const std::string& name, const std::string& uri); void OrthancJob::CallbackFinalize(void* job); float OrthancJob::CallbackGetProgress(void* job); const char* OrthancJob::CallbackGetContent(void* job); const char* OrthancJob::CallbackGetSerialized(void* job); OrthancPluginJobStepStatus OrthancJob::CallbackStep(void* job); OrthancPluginErrorCode OrthancJob::CallbackStop(void* job, OrthancPluginJobStopReason reason); OrthancPluginErrorCode OrthancJob::CallbackReset(void* job); void OrthancJob::ClearContent(); void OrthancJob::UpdateContent(const Json::Value& content); void OrthancJob::ClearSerialized(); void OrthancJob::UpdateSerialized(const Json::Value& serialized); void OrthancJob::UpdateProgress(float progress); OrthancJob::OrthancJob(const std::string& jobType); OrthancPluginJob* OrthancJob::Create(OrthancJob* job); std::string OrthancJob::Submit(OrthancJob* job, int priority); MetricsTimer::MetricsTimer(const char* name); MetricsTimer::~MetricsTimer(); static RequestBodyWrapper& GetObject(void* body); RequestBodyWrapper(IRequestBody& body); static uint8_t IsDone(void* body); static const void* GetChunkData(void* body); static uint32_t GetChunkSize(void* body); static OrthancPluginErrorCode Next(void* body); HttpClient::HttpClient(); void HttpClient::AddHeaders(const HttpHeaders& headers); void HttpClient::SetCredentials(const std::string& username, const std::string& password); void HttpClient::ClearCredentials(); void HttpClient::ClearCertificate(); void HttpClient::ClearBody(); void HttpClient::SwapBody(std::string& body); void HttpClient::SetBody(const std::string& body); void HttpClient::SetBody(IRequestBody& body); HeadersWrapper(const HttpClient::HttpHeaders& headers); void AddStaticString(const char* key, const char* value); uint32_t GetCount(); const char* const* GetKeys(); const char* const* GetValues(); MemoryRequestBody(const std::string& body); virtual bool ReadNextChunk(std::string& chunk); ChunkedBuffer(); ~ChunkedBuffer(); void Clear(); void Flatten(std::string& target); void AddChunk(const void* data, size_t size); void AddChunk(const std::string& chunk); const HttpClient::HttpHeaders& GetHeaders(); ChunkedBuffer& GetBody(); virtual void AddHeader(const std::string& key, const std::string& value); virtual void AddChunk(const void* data, size_t size); void HttpClient::Execute(IAnswer& answer); void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, std::string& answerBody /* out */); void HttpClient::Execute(HttpHeaders& answerHeaders /* out */, Json::Value& answerBody /* out */); void HttpClient::Execute(); IChunkedRequestReader *NullChunkedRestCallback(const char* url, const OrthancPluginHttpRequest* request); void ChunkedRequestReaderFinalize( OrthancPluginServerChunkedRequestReader* reader); void IStorageCommitmentScpHandler::Destructor(void* rawHandler); DicomInstance::DicomInstance(const OrthancPluginDicomInstance* instance); DicomInstance::DicomInstance(OrthancPluginDicomInstance* instance); DicomInstance::DicomInstance(const void* buffer, size_t size); DicomInstance::~DicomInstance(); std::string DicomInstance::GetRemoteAet(); void DicomInstance::GetJson(Json::Value& target); void DicomInstance::GetSimplifiedJson(Json::Value& target); std::string DicomInstance::GetTransferSyntaxUid(); bool DicomInstance::HasPixelData(); void DicomInstance::GetRawFrame(std::string& target, unsigned int frameIndex); OrthancImage* DicomInstance::GetDecodedFrame(unsigned int frameIndex); void DicomInstance::Serialize(std::string& target); static std::vector<std::string> WebDavConvertPath(uint32_t pathSize, const char* const* pathItems); void IWebDavCollection::Register(const std::string& uri, IWebDavCollection& collection);

65a2a728cd1f5959a7ba19992c4ade02a7ff6e0f557f8785660a00868e25d23d

mysmartgrid

libklio

libklio/msg/msg-store.cpp

MSGStore::create_reading_pair

std::pair<timestamp_t, double> MSGStore::create_reading_pair(const Json::Value& jpair) { if (jpair[1].isConvertibleTo(Json::realValue)) { const double value = jpair[1].asDouble(); if (!isnan(value)) { Json::Int64 jtimestamp = jpair[0].asInt64(); timestamp_t timestamp = time_converter->convert_from_epoch(jtimestamp); return std::pair<timestamp_t, double>(timestamp, value); } } return std::pair<timestamp_t, double>(0, 0); }

void MSGStore::open(); void MSGStore::close(); void MSGStore::check_integrity(); void MSGStore::initialize(); void MSGStore::prepare(); void MSGStore::dispose(); void MSGStore::flush(); const std::string MSGStore::str(); void MSGStore::add_sensor_record(const Sensor::Ptr sensor); void MSGStore::remove_sensor_record(const Sensor::Ptr sensor); void MSGStore::update_sensor_record(const Sensor::Ptr sensor); void MSGStore::add_single_reading_record(const Sensor::Ptr sensor, const timestamp_t timestamp, const double value, const bool ignore_errors); void MSGStore::add_bulk_reading_records(const Sensor::Ptr sensor, const readings_t& readings, const bool ignore_errors); void MSGStore::update_reading_records(const Sensor::Ptr sensor, const readings_t& readings, const bool ignore_errors); std::vector<Sensor::Ptr> MSGStore::get_sensor_records(); readings_t_Ptr MSGStore::get_all_reading_records(const Sensor::Ptr sensor); readings_t_Ptr MSGStore::get_timeframe_reading_records(const Sensor::Ptr sensor, timestamp_t begin, timestamp_t end); unsigned long int MSGStore::get_num_readings_value(const Sensor::Ptr sensor); reading_t MSGStore::get_last_reading_record(const Sensor::Ptr sensor); reading_t MSGStore::get_reading_record(const Sensor::Ptr sensor, const timestamp_t timestamp); void MSGStore::heartbeat(); const std::string MSGStore::format_uuid_string(const std::string & meter); Sensor::Ptr MSGStore::parse_sensor(const std::string& uuid_str, const Json::Value& jsensor);

d81ce2258f6f60499cdcf8a33e205b0e40ca28ccd601c296b5801db913b9e104

majestic53

libnimble

src/lib/src/nimble_lexer.cpp

_nimble_lexer_base::is_newline

bool _nimble_lexer_base::is_newline( __in size_t position, __in bool forward, __out_opt size_t *length ) { size_t len = 0; char ch, cmp0, cmp1; bool result = false, valid; TRACE_ENTRY(TRACE_VERBOSE); SERIALIZE_CALL_RECUR(m_lock); valid = (forward ? (position < m_source.size()) : true); if(valid) { ch = m_source.at(position); cmp0 = (forward ? CHAR_CARAGE_RETURN : CHAR_LINE_FEED); cmp1 = (forward ? CHAR_LINE_FEED : CHAR_CARAGE_RETURN); if(ch == cmp0) { position = (forward ? (position + 1) : (position - 1)); valid = (forward ? (position < m_source.size()) : (position > 0)); if(valid) { ch = m_source.at(position); if(ch == cmp1) { len = CHAR_NEWLINE_LONG_LEN; result = true; } else if(!forward) { len = CHAR_NEWLINE_LEN; result = true; } } } else if(ch == CHAR_LINE_FEED) { len = CHAR_NEWLINE_LEN; result = true; } } if(length) { *length = len; } TRACE_EXIT_MESSAGE(TRACE_VERBOSE, "res. 0x%x", result); return result; }

_nimble_lexer_base::~_nimble_lexer_base(void); char _nimble_lexer_base::character(void); char_cls_t _nimble_lexer_base::character_class(void); size_t _nimble_lexer_base::character_column(void); std::string _nimble_lexer_base::character_line(void); size_t _nimble_lexer_base::character_position(void); size_t _nimble_lexer_base::character_row(void); void _nimble_lexer_base::clear(void); size_t _nimble_lexer_base::discover(void); bool _nimble_lexer_base::has_next_character(void); bool _nimble_lexer_base::has_path(void); bool _nimble_lexer_base::has_previous_character(void); std::string _nimble_lexer_base::path(void); void _nimble_lexer_base::reset(void); size_t _nimble_lexer_base::size(void); std::string _nimble_lexer_base::source(void); _nimble_lexer::~_nimble_lexer(void); nimble_token_factory_ptr _nimble_lexer::acquire_token(void); void _nimble_lexer::clear(void); size_t _nimble_lexer::discover(void); bool _nimble_lexer::has_next_token(void); bool _nimble_lexer::has_previous_token(void); nimble_token & _nimble_lexer::move_next_token(void); nimble_token & _nimble_lexer::move_previous_token(void); void _nimble_lexer::reset(void); size_t _nimble_lexer::size(void); void _nimble_lexer::skip_whitespace(void); nimble_token & _nimble_lexer::token(void); nimble_token & _nimble_lexer::token_begin(void); nimble_token & _nimble_lexer::token_end(void);

04a3be44fdc8a97e01d5fc9ddbda86b6ed075f21d6d41d3c316905fb60b9e98f

InkVisible

wow

src/server/scripts/Outland/Auchindoun/ShadowLabyrinth/boss_grandmaster_vorpil.cpp

UpdateAI

void UpdateAI(const uint32 diff) { if (!VorpilGUID) { me->Kill(me); return; } if (move <= diff) { Creature *Vorpil = Unit::GetCreature(*me, VorpilGUID); if (!Vorpil) { VorpilGUID = 0; return; } if (sacrificed) { me->AddAura(DUNGEON_MODE(SPELL_EMPOWERING_SHADOWS, H_SPELL_EMPOWERING_SHADOWS), Vorpil); Vorpil->SetHealth(Vorpil->GetHealth() + Vorpil->GetMaxHealth()/25); DoCast(me, SPELL_SHADOW_NOVA, true); me->Kill(me); return; } me->GetMotionMaster()->MoveFollow(Vorpil,0,0); if (me->IsWithinDist(Vorpil, 3)) { DoCast(me, SPELL_SACRIFICE, false); sacrificed = true; move = 500; return; } if (!Vorpil->isInCombat() || Vorpil->isDead()) { me->Kill(me); return; } move = 1000; } else move -= diff; }

CreatureAI* GetAI(Creature* pCreature); mob_voidtravelerAI(Creature *c); void Reset(); CreatureAI* GetAI(Creature* pCreature); boss_grandmaster_vorpilAI(Creature *c); void Reset(); void summonPortals(); void destroyPortals(); void spawnVoidTraveler(); void JustSummoned(Creature *summoned); void KilledUnit(Unit * /*victim*/); void JustDied(Unit * /*victim*/); void EnterCombat(Unit * /*who*/); void MoveInLineOfSight(Unit *who); void UpdateAI(const uint32 diff); void AddSC_boss_grandmaster_vorpil();

7fc9e018ea5e725c7dc737eca32be73193bfe2d7848b11424338d5e50bc3c356

raynorpat

cake

src_radiant/plugins/model/model.cpp

render

void render(Renderer& renderer, const Matrix4& localToWorld, Shader* state) const { renderer.SetState(state, Renderer::eFullMaterials); renderer.addRenderable(*this, localToWorld); }

void addLight(const RendererLight& light); void clear(); void evaluateLights(); void lightsChanged(); void forEachLight(const RendererLightCallback& callback); PicoSurface(); PicoSurface(picoSurface_t* surface); ~PicoSurface(); void render(RenderStateFlags state); VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld); const AABB& localAABB(); void render(Renderer& renderer, const Matrix4& localToWorld); void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld); const char* getShader(); Shader* getState(); void CaptureShader(); void ReleaseShader(); void UpdateAABB(); void testSelect(SelectionTest& test, SelectionIntersection& best); void CopyPicoSurface(picoSurface_t* surface); void constructQuad(std::size_t index, const Vector3& a, const Vector3& b, const Vector3& c, const Vector3& d, const Vector3& normal); void constructNull(); PicoModel(); PicoModel(picoModel_t* model); ~PicoModel(); const_iterator begin(); const_iterator end(); std::size_t size(); VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld); virtual const AABB& localAABB(); void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld, std::vector<Shader*> states); void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld); void CopyPicoModel(picoModel_t* model); void constructNull(); inline void Surface_addLight(PicoSurface& surface, VectorLightList& lights, const Matrix4& localToWorld, const RendererLight& light); TypeCasts(); InstanceTypeCastTable& get(); Remap(); Bounded& get(NullType<Bounded>); Cullable& get(NullType<Cullable>); void lightsChanged(); void constructRemaps(); void destroyRemaps(); void skinChanged(); PicoModelInstance(const scene::Path& path, scene::Instance* parent, PicoModel& picomodel); ~PicoModelInstance(); void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld); void renderSolid(Renderer& renderer, const VolumeTest& volume); void renderWireframe(Renderer& renderer, const VolumeTest& volume); void testSelect(Selector& selector, SelectionTest& test); bool testLight(const RendererLight& light); void insertLight(const RendererLight& light); void clearLights(); TypeCasts(); NodeTypeCastTable& get(); PicoModelNode(); PicoModelNode(picoModel_t* model); void release(); scene::Node& node(); scene::Instance* create(const scene::Path& path, scene::Instance* parent); void forEachInstance(const scene::Instantiable::Visitor& visitor); void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance); scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path); static Type* construct(const Key& key); static void destroy(Type* value); inline ~cache_element(); inline Type* capture(const Key& key); inline void release(); inline bool empty(); inline void refresh(const Key& key); inline void construct(const Key& key); inline void destroy(); static value_type* construct(const key_type& key); static void destroy(value_type* value); value_type* capture(const key_type& key); void release(const key_type& key); RemapWrapper(const char* name); virtual ~RemapWrapper(); VolumeIntersectionValue intersectVolume(const VolumeTest& test, const Matrix4& localToWorld); virtual const AABB& localAABB(); void render(Renderer& renderer, const VolumeTest& volume, const Matrix4& localToWorld); void testSelect(Selector& selector, SelectionTest& test, const Matrix4& localToWorld); void add_remap(const char *remap); void parse_namestr(const char *name); void construct_shaders(); inline const char* shader_for_remap(const char* remap); RemapWrapperInstance(const scene::Path& path, scene::Instance* parent, RemapWrapper& remapwrapper); void renderSolid(Renderer& renderer, const VolumeTest& volume); void renderWireframe(Renderer& renderer, const VolumeTest& volume); void testSelect(Selector& selector, SelectionTest& test); RemapWrapperNode(const char* name); void release(); scene::Node& node(); scene::Instance* create(const scene::Path& path, scene::Instance* parent); void forEachInstance(const scene::Instantiable::Visitor& visitor); void insert(scene::Instantiable::Observer* observer, const scene::Path& path, scene::Instance* instance); scene::Instance* erase(scene::Instantiable::Observer* observer, const scene::Path& path); scene::Node& LoadRemapModel(const char* name); size_t picoInputStreamReam(void* inputStream, unsigned char* buffer, size_t length); scene::Node& loadPicoModel(const picoModule_t* module, ArchiveFile& file);

9604efd3a2809143c1a02a1c62166008407baecb17c4fda9a70c44af774835d9

d1100

Ipopt

src/Algorithm/IpIpoptAlg.cpp

IpoptAlgorithm::~IpoptAlgorithm

IpoptAlgorithm::~IpoptAlgorithm() { DBG_START_METH("IpoptAlgorithm::~IpoptAlgorithm()", dbg_verbosity); }

static void print_message(const Journalist& jnlst); void IpoptAlgorithm::RegisterOptions(SmartPtr<RegisteredOptions> roptions); bool IpoptAlgorithm::InitializeImpl(const OptionsList& options, const std::string& prefix); SolverReturn IpoptAlgorithm::Optimize(); void IpoptAlgorithm::UpdateHessian(); bool IpoptAlgorithm::UpdateBarrierParameter(); bool IpoptAlgorithm::ComputeSearchDirection(); void IpoptAlgorithm::ComputeAcceptableTrialPoint(); void IpoptAlgorithm::OutputIteration(); void IpoptAlgorithm::InitializeIterates(); void IpoptAlgorithm::AcceptTrialPoint(); void IpoptAlgorithm::PrintProblemStatistics();

6f0ec968cd0c9c1ab3522d23d583636092b0b87517657f01768a603e3fbaca46

sephirot47

RealEngine

src/Quaternion.cpp

Quaternion::FromAxes

Quaternion Quaternion::FromAxes(const glm::vec3 xAxis, const glm::vec3 yAxis, const glm::vec3 zAxis) { glm::mat3 kRot; kRot[0] = xAxis; kRot[1] = yAxis; kRot[2] = zAxis; return Quaternion(glm::quat_cast(kRot)); }

Quaternion::Quaternion(); Quaternion::Quaternion(glm::quat q); Quaternion Quaternion::Normalized(); Quaternion Quaternion::LookAt(const glm::vec3 eye, const glm::vec3 lookTo, const glm::vec3 up); Quaternion Quaternion::AxisAngle(const glm::vec3 axis, float degrees); Quaternion Quaternion::FromTo(const glm::vec3 from, const glm::vec3 to);

26332be8849de5a37ab155b036b49ead0274ee40aedc1d423013e22b7405dbf4

mkollaro

nsim

src/gui/animation.cpp

Animation::~Animation

Animation::~Animation() { makeCurrent(); logger->stopLogging(); doneCurrent(); }

void Animation::mousePressEvent(QMouseEvent *e); void Animation::mouseMoveEvent(QMouseEvent *e); void Animation::timerEvent(QTimerEvent *); void Animation::initializeLogging(); void Animation::initializeShaders(); void Animation::initializeGL(); void Animation::resizeGL(int w, int h); void Animation::paintGL(); void Animation::printGlErrors(); QString Animation::glErrorToString(GLenum error_code);

dd7bc252b05ae17de8396ec19c54c2b72ebe0da2a94f6242d44b62689df66b88

ozen

PyOptiX

driver/group.cpp

NativeGroupWrapper::get_child_count

unsigned int NativeGroupWrapper::get_child_count() { return this->group->getChildCount(); }

NativeGroupWrapper::NativeGroupWrapper(optix::Group group); NativeGroupWrapper::~NativeGroupWrapper(); void NativeGroupWrapper::set_acceleration(NativeAccelerationWrapper* acceleration); void NativeGroupWrapper::set_child_count(unsigned int count); void NativeGroupWrapper::set_child_geometry_group(unsigned int index, NativeGeometryGroupWrapper* child); void NativeGroupWrapper::set_child_group(unsigned int index, NativeGroupWrapper* child); void NativeGroupWrapper::set_child_selector(unsigned int index, NativeSelectorWrapper* child); void NativeGroupWrapper::set_child_transform(unsigned int index, NativeTransformWrapper* child); void NativeGroupWrapper::set_child_acceleration(unsigned int index, NativeAccelerationWrapper* child); void NativeGroupWrapper::remove_child(unsigned int index); optix::Group NativeGroupWrapper::get_native(); void NativeGroupWrapper::boost_python_expose();

fa4cd274208b998626507702c23bd5732f4defccfb477e437101cab5bde53b77

melinsoftware

meos

code/oCourse.cpp

&oCourse::getTable

r<Table> &oCourse::getTable(oEvent *oe) { oe->synchronizeList(oListId::oLCourseId); oClassList::iterator it; int numCtrl = 20; vector <pCourse> crs; oe->getCourses(crs); for (pCourse pc : crs) numCtrl = max(numCtrl, pc->getNumControls() + 5); static int generatedNumCtrl = 0; if (generatedNumCtrl != numCtrl || !oe->hasTable("course")) { auto table = make_shared<Table>(oe, 20, L"Banor", "courses"); table->addColumn("Id", 70, true, true); table->addColumn("Ändrad", 70, false); table->addColumn("Namn", 200, false); table->addColumn("Startande", 70, true); table->addColumn("Klasser", 200, false); for (int i = 0; i < numCtrl; i++) table->addColumn("#C" + itos(i + 1), 40, true, true); generatedNumCtrl = numCtrl; oe->oCourseData->buildTableCol(table.get()); oe->setTable("course", table); } return oe->getTable("course"); } void oCourse:

ourse::oCourse(oEvent *poe); ourse::oCourse(oEvent *poe, int id); ourse::~oCourse(); tring oCourse::getInfo(); ol oCourse::Write(xmlparser &xml); id oCourse::Set(const xmlobject *xo); ring oCourse::getLegLengths(); ring oCourse::getControls(); tring oCourse::getControlsUI(); ctor<wstring> oCourse::getCourseReadable(int limit); ntrol oCourse::addControl(int Id); ntrol oCourse::doAddControl(int Id); oCourse::splitControls(const string &ctrls, vector<int> &nr); oCourse::importControls(const string &ctrls, bool setChanged, bool updateLegLengths); oCourse::importLegLengths(const string &legs, bool setChanged); rol *oCourse::getControl(int index); Course::getLegLength(int index); oCourse::fillCourse(gdioutput &gdi, const string &name); ourse::getControls(vector<pControl> &pc); int> oCourse::getControlNumbers(); urse::distance(const SICard &card); oCourse::getLengthS(); ourse::setName(const wstring &n); ourse::setLength(int le); ntainer &oCourse::getDataBuffers(pvoid &data, pvoid &olddata, pvectorstr &strData); oEvent::getCourseCreate(int Id); oEvent::getCourse(int Id); oEvent::getCourse(const wstring &n); vent::fillCourses(gdioutput &gdi, const string &id, bool simple); ector< pair<wstring, size_t> > &oEvent::fillCourses(vector< pair<wstring, size_t> > &out, bool simple); ourse::setNumberMaps(int block); urse::getNumberMaps(); urse::getNumUsedMaps(bool noVacant); ourse::setStart(const wstring &start, bool sync); oCourse::getStart(); vent::calculateNumRemainingMaps(bool forceRecalculate); urse::getIdSum(int nC); ourse::setLegLengths(const vector<int> &legs); oCourse::getPartOfCourse(int start, int end); string &oCourse::getControlOrdinal(int controlIndex); urse::setRogainingPointsPerMinute(int p); rse::getRogainingPointsPerMinute(); rse::calculateReduction(int overTime); urse::setMinimumRogainingPoints(int p); rse::getMinimumRogainingPoints(); urse::setMaximumRogainingTime(int p); rse::getMaximumRogainingTime(); urse::hasRogaining(); urse::clearCache(); oCourse::getCourseProblems(); remove(); canRemove(); changeId(int newId); useFirstAsStart(); useLastAsFinish(); firstAsStart(bool f); lastAsFinish(bool f); etFinishPunchType(); etStartPunchType(); etCourses(vector<pCourse> &crs); etCommonControl(); etNumLoops(); setCommonControl(int ctrlId); ::getAdapetedCourse(const oCard &card, oCourse &tmpCourse, int &numShorten); sAdapted(); tAdaptionId(); tchLoopKey(const vector<int> &punches, const vector<pControl> &key); onstructLoopKeys(int cc, vector< vector<pControl> > &loopKeys, vector<int> &ccIndex); hangedObject(); tCourseControlId(int controlIx); ::getRadioName(int courseControlId); rse> oCourse::getShorterVersion(); ::getLongerVersion(); etShorterVersion(bool activeShortening, pCourse shorten); asControl(const oControl *ctrl); asControlCode(int code); etClasses(vector<pClass> &usageClass); nerateTableData(oEvent *oe, Table &table, oCourse *add); dTableRow(Table &table); oCourse::inputData(int id, const wstring &input, int inputId, wstring &output, bool noUpdate); llInput(int id, vector< pair<wstring, size_t> > &out, size_t &selected);

5d177196f658d2d390ca80efe525f8ba86b082bddf62cb0adb48a1f035fc5397

iso9660

linux-sdk

SDKLinux/LFC/XWidgets/Events/controleventkey.cpp

ControlEventKey::PressedMod4

bool ControlEventKey::PressedMod4() { return status & StatusPressedMod4; }

ControlEventKey::ControlEventKey(const WindowEventKey &e, const KeyCompositionSymbol &s); ControlEventKey::~ControlEventKey(); DateTime ControlEventKey::Time(); NPoint ControlEventKey::Position(); NPoint ControlEventKey::PositionRoot(); KeyCompositionSymbol ControlEventKey::Symbol(); bool ControlEventKey::PressedButton1(); bool ControlEventKey::PressedButton2(); bool ControlEventKey::PressedButton3(); bool ControlEventKey::PressedButton4(); bool ControlEventKey::PressedButton5(); bool ControlEventKey::PressedControl(); bool ControlEventKey::PressedLock(); bool ControlEventKey::PressedShift(); bool ControlEventKey::PressedMod1(); bool ControlEventKey::PressedMod2(); bool ControlEventKey::PressedMod3(); bool ControlEventKey::PressedMod5(); ControlEventKey &ControlEventKey::operator =(const ControlEventKey &e);

ea649a0ca960ba35b3e76de71e8fe399958544ef5548b89b6f3e5e0c52a0dc54

xiao0613cn

AModule

ecs/AClientSystem.cpp

client_com_create

static int client_com_create(AObject **object, AObject *parent, AOption *option) { AClientComponent *c = (AClientComponent*)object; c->init(c->name()); c->init2(); if (parent != NULL) ((AEntity*)parent)->push(c); if (option != NULL) { c->_tick_reopen = option->getInt("tick_reopen", c->_tick_reopen/1000)*1000; c->_tick_heart = option->getInt("tick_heart", c->_tick_heart/1000)*1000; c->_tick_abort = option->getInt("tick_abort", c->_tick_abort/1000)*1000; c->_owner_thread = !!option->getInt("owner_thread", c->_owner_thread); c->_open_heart = !!option->getInt("open_heart", c->_open_heart); c->_auto_reopen = !!option->getInt("auto_reopen", c->_auto_reopen); c->_auto_remove = !!option->getInt("auto_remove", c->_auto_remove); } c->open = &client_com_null; c->close = &client_com_null; return 1; }

static ASystem::Result* check_one(ASystemManager *sm, AClientComponent *c, DWORD cur_tick); static ASystem::Result* client_check(ASystemManager *sm, AEntity *e, DWORD cur_tick); static int client_run_internal(ASystem::Result *r, int result); static void* client_run_thread(void *p); static int client_run(ASystem::Result *r, int result); static int client_abort(ASystem::Result *r); static int reg_client(AEntity *e); static int unreg_client(AEntity *e); static int clear_all(bool abort); static int check_all(ASystemManager *sm, list_head *results, DWORD cur_tick); static int client_com_null(AClientComponent *c);

fe7f88ac38ea72ec960d23c113ecd0ba805133a59bc6d866b15fdaa21a31c43e

scpeters

chrono

src/physics/ChRef.cpp

ChRefFunctionHandle::SetHandleId

int ChRefFunctionHandle::SetHandleId(int m_hid) { handle_id = m_hid; this->RestoreReference(this->function); return TRUE; }

ChRefFunctionSegment::ChRefFunctionSegment(ChFunction* mrootf, char* myIDs); bool ChRefFunctionSegment::RestoreReference(ChFunction* mrootf); int ChRefFunctionSegment::SetTreeIDs(char* myIDs); ChRefFunctionHandle::ChRefFunctionHandle(ChFunction* mrootf,int m_hid); bool ChRefFunctionHandle::RestoreReference(ChFunction* mrootf); int ChRefFunctionHandle::AccessHandle(double& mx, double& my, bool set_mode);

cb3da2b91895eed20082a8b6dc5a39fea2cd0f60f2ec7def1ce3df8e36a511dd

MassEffectModder

MassEffectModderQt

MassEffectModder/Logs/Logs.cpp

Logs::printMsgTimeStamp

void Logs::printMsgTimeStamp(QString &message) { bool oldState = _timeStampEnabled; _timeStampEnabled = true; this->printf("%s\n", message.toStdString().c_str()); _timeStampEnabled = oldState; }

Logs::Logs(); Logs::~Logs(); bool Logs::init(); bool Logs::deinit(); void Logs::printf(const char *format, ...); void Logs::print(const char *message); void Logs::printline(const char *message); void Logs::printMsg(QString &message); bool CreateLogs(); void ReleaseLogs();

cdda990ac86d288b13dad233a7455731825ca1f754115c91cd5875c1d3fab35a

mariusmm

cursembedded

Simplicity/AplicacioModbusCPP/src/main.cpp

process

void process(void) { mod_client.Slave(); if (letimer.Triggered()) { letimer.Processed(); uint16_t distance = 0; uint16_t threshold_max; uint16_t threshold_min; distance = my_sensor.GetDistance(); threshold_max = register_file.direct_read(REGISTER_THRES_HIGH); threshold_min = register_file.direct_read(REGISTER_THRES_LOW); register_file.direct_write(REGISTER_DISTANCE, distance); if ((distance > threshold_max) || (distance < threshold_min)) { RELAY1Pin.Set(); LEDPin.Set(); } else { RELAY1Pin.Reset(); LEDPin.Reset(); } } }

Application(); void callback(unsigned int reg_num, int data); void app_LEDUpdate_cb(int reg, int data); void app_RelayUpdate_cb(int reg, int data); void app_timer_reg_cb(int reg, int data); void app_APDS9960Distance_cb(int reg, int data); int main(void);

49cae574588f2a382d0831e2aff9c1eebcfccf291ce23bbb57645ab746b7c1c3

gregkalapos

corert

src/Native/Runtime/RHCodeMan.cpp

ReportObject

inline void ReportObject(GCEnumContext * hCallback, PTR_PTR_Object p, UInt32 flags) { (hCallback->pCallback)(hCallback, (PTR_PTR_VOID)p, flags); }

EEMethodInfo * GetEEMethodInfo(MethodInfo * pMethodInfo); PTR_PTR_Object GetRegObjectAddr(REGDISPLAY * pContext); PTR_PTR_Object GetRegObjectAddr(CalleeSavedRegNum regNum, REGDISPLAY * pContext); PTR_PTR_Object GetScratchRegObjectAddr(ScratchRegNum regNum, REGDISPLAY * pContext); void ReportRegisterSet(UInt8 regSet, REGDISPLAY * pContext, GCEnumContext * hCallback); PTR_PTR_Object GetRegObjectAddr(REGDISPLAY * pContext); PTR_PTR_Object GetRegObjectAddr(CalleeSavedRegNum regNum, REGDISPLAY * pContext); PTR_PTR_Object GetScratchRegObjectAddr(ScratchRegNum regNum, REGDISPLAY * pContext); void ReportRegisterSet(UInt8 firstEncByte, REGDISPLAY * pContext, GCEnumContext * hCallback, PTR_UInt8 & pCursor); PTR_PTR_Object GetRegObjectAddr(REGDISPLAY * pContext); PTR_PTR_Object GetRegObjectAddr(CalleeSavedRegNum regNum, REGDISPLAY * pContext); PTR_PTR_Object GetScratchRegObjectAddr(ScratchRegNum regNum, REGDISPLAY * pContext); void ReportRegisterSet(UInt8 regSet, REGDISPLAY * pContext, GCEnumContext * hCallback); void ReportRegister(UInt8 regEnc, REGDISPLAY * pContext, GCEnumContext * hCallback, PTR_UInt8 & pCursor); void ReportLocalSlot(UInt32 slotNum, REGDISPLAY * pContext, GCEnumContext * hCallback, GCInfoHeader * pHeader); void ReportLocalSlots(UInt8 localsEnc, REGDISPLAY * pContext, GCEnumContext * hCallback, GCInfoHeader * pHeader); void ReportStackSlots(UInt8 firstEncByte, REGDISPLAY * pContext, GCEnumContext * hCallback, PTR_UInt8 & pCursor, bool hasDynamicAlignment); UInt32 ReadRegisterMaskBy7Bit(PTR_UInt8 & pCursor); void ReportScratchRegs(UInt8 firstEncByte, REGDISPLAY * pContext, GCEnumContext * hCallback, PTR_UInt8 & pCursor); PTR_VOID EECodeManager::GetReversePInvokeSaveFrame(GCInfoHeader * pHeader, REGDISPLAY * pContext); UIntNative EECodeManager::GetConservativeUpperBoundForOutgoingArgs(GCInfoHeader * pInfoHeader, REGDISPLAY * pContext); GCRefKind EECodeManager::GetReturnValueKind(GCInfoHeader * pInfoHeader); inline bool IsFramelessArm64(void); void CheckHijackInEpilog(GCInfoHeader * pInfoHeader, Code * pEpilog, Code * pEpilogStart, UInt32 epilogSize); bool VerifyEpilogBytesX86(GCInfoHeader * pInfoHeader, Code * pEpilogStart, UInt32 epilogSize); bool VerifyEpilogBytesAMD64(GCInfoHeader * pInfoHeader, Code * pEpilogStart, UInt32 epilogSize); bool VerifyEpilogBytesARM(GCInfoHeader * pInfoHeader, Code * pEpilogStart, UInt32 epilogSize); bool VerifyEpilogBytesARM64(GCInfoHeader * pInfoHeader, Code * pEpilogStart, UInt32 epilogSize); bool EECodeManager::VerifyEpilogBytes(GCInfoHeader * pInfoHeader, Code * pEpilogStart, UInt32 epilogSize); void EECodeManager::VerifyProlog(EEMethodInfo * /*pMethodInfo*/); void EECodeManager::VerifyEpilog(EEMethodInfo * pMethodInfo); void EEMethodInfo::Init(PTR_VOID pvCode, UInt32 cbCodeSize, PTR_UInt8 pbRawGCInfo, PTR_VOID pvEHInfo); void EEMethodInfo::DecodeGCInfoHeader(UInt32 methodOffset, PTR_UInt8 pbUnwindInfoBlob); PTR_UInt8 EEMethodInfo::GetGCInfo(); PTR_UInt8 EEMethodInfo::GetEpilogTable(); GCInfoHeader * EEMethodInfo::GetGCInfoHeader();

d70d3136939f17c265856cb02d586b0339284064291c433fd6b501f4a0831708

richelbilderbeek

ProjectThorVeen

UnitCouple.cpp

Couple::getMale

boost::shared_ptr<BirdBase> Couple::getMale() { boost::shared_ptr<BirdBase> male(mMale); mMale.reset(); return male; }

Couple::Couple(boost::shared_ptr<BirdBase>& female, boost::shared_ptr<BirdBase>& male); Couple::~Couple(); boost::shared_ptr<BirdBase> Couple::createOneOffspring(); boost::shared_ptr<BirdBase> Couple::getFemale(); bool Couple::isFemaleNull(); bool Couple::isMaleNull();

bf4ed76491748316b2e641cdd51d1fc2335dceb21fae5f4b7028fbe44de325fe

chadnickbok

librtcdcpp

examples/websocket_client/jsoncpp.cpp

Value::operator<

bool Value::operator<(const Value& other) const { int typeDelta = type_ - other.type_; if (typeDelta) return typeDelta < 0 ? true : false; switch (type_) { case nullValue: return false; case intValue: return value_.int_ < other.value_.int_; case uintValue: return value_.uint_ < other.value_.uint_; case realValue: return value_.real_ < other.value_.real_; case booleanValue: return value_.bool_ < other.value_.bool_; case stringValue: { if ((value_.string_ == 0) || (other.value_.string_ == 0)) { if (other.value_.string_) return true; else return false; } unsigned this_len; unsigned other_len; char const* this_str; char const* other_str; decodePrefixedString(this->allocated_, this->value_.string_, &this_len, &this_str); decodePrefixedString(other.allocated_, other.value_.string_, &other_len, &other_str); unsigned min_len = std::min(this_len, other_len); JSON_ASSERT(this_str && other_str); int comp = memcmp(this_str, other_str, min_len); if (comp < 0) return true; if (comp > 0) return false; return (this_len < other_len); } case arrayValue: case objectValue: { int delta = int(value_.map_->size() - other.value_.map_->size()); if (delta) return delta < 0; return (*value_.map_) < (*other.value_.map_); } default: JSON_ASSERT_UNREACHABLE; } return false; }

static inline JSONCPP_STRING codePointToUTF8(unsigned int cp); static inline void uintToString(LargestUInt value, char*& current); static inline void fixNumericLocale(char* begin, char* end); Features Features::strictMode(); static bool containsNewLine(Reader::Location begin, Reader::Location end); Reader::Reader(); Reader::Reader(const Features& features); bool Reader::parse(const std::string& document, Value& root, bool collectComments); bool Reader::parse(std::istream& sin, Value& root, bool collectComments); bool Reader::parse(const char* beginDoc, const char* endDoc, Value& root, bool collectComments); bool Reader::readValue(); void Reader::skipCommentTokens(Token& token); bool Reader::readToken(Token& token); void Reader::skipSpaces(); bool Reader::match(Location pattern, int patternLength); bool Reader::readComment(); static JSONCPP_STRING normalizeEOL(Reader::Location begin, Reader::Location end); void Reader::addComment(Location begin, Location end, CommentPlacement placement); bool Reader::readCStyleComment(); bool Reader::readCppStyleComment(); void Reader::readNumber(); bool Reader::readString(); bool Reader::readObject(Token& tokenStart); bool Reader::readArray(Token& tokenStart); bool Reader::decodeNumber(Token& token); bool Reader::decodeNumber(Token& token, Value& decoded); bool Reader::decodeDouble(Token& token); bool Reader::decodeDouble(Token& token, Value& decoded); bool Reader::decodeString(Token& token); bool Reader::decodeString(Token& token, JSONCPP_STRING& decoded); bool Reader::decodeUnicodeCodePoint(Token& token, Location& current, Location end, unsigned int& unicode); bool Reader::decodeUnicodeEscapeSequence(Token& token, Location& current, Location end, unsigned int& ret_unicode); bool Reader::addError(const JSONCPP_STRING& message, Token& token, Location extra); bool Reader::recoverFromError(TokenType skipUntilToken); bool Reader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token, TokenType skipUntilToken); Reader::Char Reader::getNextChar(); void Reader::getLocationLineAndColumn(Location location, int& line, int& column); JSONCPP_STRING Reader::getLocationLineAndColumn(Location location); JSONCPP_STRING Reader::getFormattedErrorMessages(); std::vector<Reader::StructuredError> Reader::getStructuredErrors(); bool Reader::pushError(const Value& value, const JSONCPP_STRING& message); bool Reader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra); OurReader::OurReader(OurFeatures const& features); bool OurReader::parse(const char* beginDoc, const char* endDoc, Value& root, bool collectComments); bool OurReader::readValue(); void OurReader::skipCommentTokens(Token& token); bool OurReader::readToken(Token& token); void OurReader::skipSpaces(); bool OurReader::match(Location pattern, int patternLength); bool OurReader::readComment(); void OurReader::addComment(Location begin, Location end, CommentPlacement placement); bool OurReader::readCStyleComment(); bool OurReader::readCppStyleComment(); bool OurReader::readNumber(bool checkInf); bool OurReader::readString(); bool OurReader::readStringSingleQuote(); bool OurReader::readObject(Token& tokenStart); bool OurReader::readArray(Token& tokenStart); bool OurReader::decodeNumber(Token& token); bool OurReader::decodeNumber(Token& token, Value& decoded); bool OurReader::decodeDouble(Token& token); bool OurReader::decodeDouble(Token& token, Value& decoded); bool OurReader::decodeString(Token& token); bool OurReader::decodeString(Token& token, JSONCPP_STRING& decoded); bool OurReader::decodeUnicodeCodePoint(Token& token, Location& current, Location end, unsigned int& unicode); bool OurReader::decodeUnicodeEscapeSequence(Token& token, Location& current, Location end, unsigned int& ret_unicode); bool OurReader::addError(const JSONCPP_STRING& message, Token& token, Location extra); bool OurReader::recoverFromError(TokenType skipUntilToken); bool OurReader::addErrorAndRecover(const JSONCPP_STRING& message, Token& token, TokenType skipUntilToken); OurReader::Char OurReader::getNextChar(); void OurReader::getLocationLineAndColumn(Location location, int& line, int& column); JSONCPP_STRING OurReader::getLocationLineAndColumn(Location location); JSONCPP_STRING OurReader::getFormattedErrorMessages(); std::vector<OurReader::StructuredError> OurReader::getStructuredErrors(); bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message); bool OurReader::pushError(const Value& value, const JSONCPP_STRING& message, const Value& extra); bool parse(char const* beginDoc, char const* endDoc, Value* root, JSONCPP_STRING* errs); CharReader* CharReaderBuilder::newCharReader(); static void getValidReaderKeys(std::set<JSONCPP_STRING>* valid_keys); bool CharReaderBuilder::validate(Json::Value* invalid); void CharReaderBuilder::strictMode(Json::Value* settings); void CharReaderBuilder::setDefaults(Json::Value* settings); bool parseFromStream(CharReader::Factory const& fact, JSONCPP_ISTREAM& sin, Value* root, JSONCPP_STRING* errs); JSONCPP_ISTREAM& operator>>(JSONCPP_ISTREAM& sin, Value& root); ValueIteratorBase::difference_type ValueIteratorBase::computeDistance(const SelfType& other); bool ValueIteratorBase::isEqual(const SelfType& other); void ValueIteratorBase::copy(const SelfType& other); Value ValueIteratorBase::key(); UInt ValueIteratorBase::index(); JSONCPP_STRING ValueIteratorBase::name(); char const* ValueIteratorBase::memberName(); char const* ValueIteratorBase::memberName(char const** end); ValueConstIterator& ValueConstIterator::operator=(const ValueIteratorBase& other); ValueIterator::ValueIterator(const ValueConstIterator& other); ValueIterator& ValueIterator::operator=(const SelfType& other); Value const& Value::nullSingleton(); static inline bool InRange(double d, T min, U max); static inline double integerToDouble(Json::UInt64 value); static inline double integerToDouble(T value); static inline bool InRange(double d, T min, U max); static inline char* duplicateStringValue(const char* value, size_t length); static inline char* duplicateAndPrefixStringValue(const char* value, unsigned int length); inline static void decodePrefixedString(bool isPrefixed, char const* prefixed, unsigned* length, char const** value); static inline void releasePrefixedStringValue(char* value); static inline void releaseStringValue(char* value, unsigned length); Value::CommentInfo::~CommentInfo(); void Value::CommentInfo::setComment(const char* text, size_t len); Value::CZString::CZString(char const* str, unsigned ulength, DuplicationPolicy allocate); Value::CZString::CZString(const CZString& other); Value::CZString::~CZString(); void Value::CZString::swap(CZString& other); Value::CZString& Value::CZString::operator=(CZString other); bool Value::CZString::operator<(const CZString& other); bool Value::CZString::operator==(const CZString& other); Value::Value(ValueType vtype); Value::Value(Int value); Value::Value(UInt value); Value::Value(Int64 value); Value::Value(UInt64 value); Value::Value(double value); Value::Value(const char* value); Value::Value(const char* beginValue, const char* endValue); Value::Value(const JSONCPP_STRING& value); Value::Value(const StaticString& value); Value::Value(const CppTL::ConstString& value); Value::Value(bool value); Value::Value(Value const& other); Value::Value(Value&& other); Value::~Value(); Value& Value::operator=(Value other); void Value::swapPayload(Value& other); void Value::swap(Value& other); int Value::compare(const Value& other); bool Value::operator==(const Value& other); const char* Value::asCString(); unsigned Value::getCStringLength(); bool Value::getString(char const** str, char const** cend); JSONCPP_STRING Value::asString(); CppTL::ConstString Value::asConstString(); Value::Int Value::asInt(); Value::UInt Value::asUInt(); Value::Int64 Value::asInt64(); Value::UInt64 Value::asUInt64(); LargestInt Value::asLargestInt(); LargestUInt Value::asLargestUInt(); double Value::asDouble(); float Value::asFloat(); bool Value::asBool(); bool Value::isConvertibleTo(ValueType other); ArrayIndex Value::size(); bool Value::empty(); void Value::clear(); void Value::resize(ArrayIndex newSize); Value& Value::operator[](ArrayIndex index); Value& Value::operator[](int index); const Value& Value::operator[](ArrayIndex index); const Value& Value::operator[](int index); void Value::initBasic(ValueType vtype, bool allocated); Value& Value::resolveReference(const char* key); Value& Value::resolveReference(char const* key, char const* cend); Value Value::get(ArrayIndex index, const Value& defaultValue); Value const* Value::find(char const* key, char const* cend); const Value& Value::operator[](const char* key); Value const& Value::operator[](JSONCPP_STRING const& key); Value const& Value::operator[](CppTL::ConstString const& key); Value Value::get(char const* key, char const* cend, Value const& defaultValue); bool Value::removeMember(const char* key, const char* cend, Value* removed); Value Value::removeMember(const char* key); bool Value::removeIndex(ArrayIndex index, Value* removed); bool Value::isMember(char const* key, char const* cend); Value::Members Value::getMemberNames(); static bool IsIntegral(double d); bool Value::isInt(); bool Value::isUInt(); bool Value::isInt64(); bool Value::isUInt64(); bool Value::isIntegral(); void Value::setComment(const char* comment, size_t len, CommentPlacement placement); JSONCPP_STRING Value::getComment(CommentPlacement placement); JSONCPP_STRING Value::toStyledString(); Value::const_iterator Value::begin(); Value::const_iterator Value::end(); Value::iterator Value::begin(); Value::iterator Value::end(); void Path::makePath(const JSONCPP_STRING& path, const InArgs& in); void Path::addPathInArg(const JSONCPP_STRING& /*path*/, const InArgs& in, InArgs::const_iterator& itInArg, PathArgument::Kind kind); void Path::invalidPath(const JSONCPP_STRING& /*path*/, int /*location*/); const Value& Path::resolve(const Value& root); Value Path::resolve(const Value& root, const Value& defaultValue); Value& Path::make(Value& root); static bool containsControlCharacter(const char* str); static bool containsControlCharacter0(const char* str, unsigned len); JSONCPP_STRING valueToString(LargestInt value); JSONCPP_STRING valueToString(LargestUInt value); JSONCPP_STRING valueToString(double value, bool useSpecialFloats, unsigned int precision); JSONCPP_STRING valueToQuotedString(const char* value); static char const* strnpbrk(char const* s, char const* accept, size_t n); static JSONCPP_STRING valueToQuotedStringN(const char* value, unsigned length); JSONCPP_STRING FastWriter::write(const Value& root); void FastWriter::writeValue(const Value& value); JSONCPP_STRING StyledWriter::write(const Value& root); void StyledWriter::writeValue(const Value& value); void StyledWriter::writeArrayValue(const Value& value); bool StyledWriter::isMultineArray(const Value& value); void StyledWriter::pushValue(const JSONCPP_STRING& value); void StyledWriter::writeIndent(); void StyledWriter::writeWithIndent(const JSONCPP_STRING& value); void StyledWriter::unindent(); void StyledWriter::writeCommentBeforeValue(const Value& root); void StyledWriter::writeCommentAfterValueOnSameLine(const Value& root); bool StyledWriter::hasCommentForValue(const Value& value); StyledStreamWriter::StyledStreamWriter(JSONCPP_STRING indentation); void StyledStreamWriter::write(JSONCPP_OSTREAM& out, const Value& root); void StyledStreamWriter::writeValue(const Value& value); void StyledStreamWriter::writeArrayValue(const Value& value); bool StyledStreamWriter::isMultineArray(const Value& value); void StyledStreamWriter::pushValue(const JSONCPP_STRING& value); void StyledStreamWriter::writeIndent(); void StyledStreamWriter::writeWithIndent(const JSONCPP_STRING& value); void StyledStreamWriter::unindent(); void StyledStreamWriter::writeCommentBeforeValue(const Value& root); void StyledStreamWriter::writeCommentAfterValueOnSameLine(const Value& root); bool StyledStreamWriter::hasCommentForValue(const Value& value); int BuiltStyledStreamWriter::write(Value const& root, JSONCPP_OSTREAM* sout); void BuiltStyledStreamWriter::writeValue(Value const& value); void BuiltStyledStreamWriter::writeArrayValue(Value const& value); bool BuiltStyledStreamWriter::isMultineArray(Value const& value); void BuiltStyledStreamWriter::pushValue(JSONCPP_STRING const& value); void BuiltStyledStreamWriter::writeIndent(); void BuiltStyledStreamWriter::writeWithIndent(JSONCPP_STRING const& value); void BuiltStyledStreamWriter::unindent(); void BuiltStyledStreamWriter::writeCommentBeforeValue(Value const& root); void BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine(Value const& root); bool BuiltStyledStreamWriter::hasCommentForValue(const Value& value); StreamWriter* StreamWriterBuilder::newStreamWriter(); static void getValidWriterKeys(std::set<JSONCPP_STRING>* valid_keys); bool StreamWriterBuilder::validate(Json::Value* invalid); void StreamWriterBuilder::setDefaults(Json::Value* settings); JSONCPP_STRING writeString(StreamWriter::Factory const& builder, Value const& root); JSONCPP_OSTREAM& operator<<(JSONCPP_OSTREAM& sout, Value const& root);

db41ef9bd8c29bad9dbdd7d77c216e03578b97e1c50a764a1358bd9c8c8b1eaf

davetcoleman

moveit

moveit_plugins/moveit_controller_manager_example/src/moveit_controller_manager_example.cpp

switchControllers

bool switchControllers(const std::vector<std::string>& activate, const std::vector<std::string>& deactivate) override { return false; }

ExampleControllerHandle(const std::string& name); bool sendTrajectory(const moveit_msgs::RobotTrajectory& t); bool cancelExecution(); bool waitForExecution(const ros::Duration&); moveit_controller_manager::ExecutionStatus getLastExecutionStatus(); MoveItControllerManagerExample(); ~MoveItControllerManagerExample(); moveit_controller_manager::MoveItControllerHandlePtr getControllerHandle(const std::string& name); void getControllersList(std::vector<std::string>& names); void getActiveControllers(std::vector<std::string>& names); virtual void getLoadedControllers(std::vector<std::string>& names); void getControllerJoints(const std::string& name, std::vector<std::string>& joints); moveit_controller_manager::MoveItControllerManager::ControllerState getControllerState(const std::string& name);

d440e9bace6c4f3b04605f2ee2e2c902d06f1b4959e3c55fecd8e569acc3d4ee

mdk194

GProxy_CurseMod_CB

gproxy/bnet.cpp

QueueChatCommand

void CBNET :: QueueChatCommand( string chatCommand, string user, bool whisper ) { if( chatCommand.empty( ) ) return; if( whisper ) QueueChatCommand( "/w " + user + " " + chatCommand ); else QueueChatCommand( chatCommand ); }

CBNET :: CBNET( CGProxy *nGProxy, string nServer, string nBNLSServer, uint16_t nBNLSPort, uint32_t nBNLSWardenCookie, string nCDKeyROC, string nCDKeyTFT, string nCountryAbbrev, string nCountry, string nUserName, string nUserPassword, string nFirstChannel, unsigned char nWar3Version, BYTEARRAY nEXEVersion, BYTEARRAY nEXEVersionHash, string nPasswordHashType, uint32_t nMaxMessageLength ); CBNET :: ~CBNET( ); BYTEARRAY CBNET :: GetUniqueName( ); vector<pair<string, int> > CBNET :: GetFriends( ); vector<pair<string, int> > CBNET :: GetClan( ); void CBNET :: SendGetFriendsList( ); void CBNET :: SendGetClanList( ); unsigned int CBNET :: SetFD( void *fd, void *send_fd, int *nfds ); bool CBNET :: Update( void *fd, void *send_fd ); void CBNET :: ExtractPackets( ); void CBNET :: ProcessPackets( ); void CBNET :: ProcessChatEvent( CIncomingChatEvent *chatEvent ); void CBNET :: SendJoinChannel( string channel ); void CBNET :: QueueEnterChat( ); void CBNET :: QueueChatCommand( string chatCommand, bool hidden ); void CBNET :: QueueGetGameList( uint32_t numGames ); void CBNET :: QueueGetGameList( string gameName ); void CBNET :: RequestListUpdates( ); void CBNET :: QueueJoinGame( string gameName ); string CBNET::Friend_Loc( string name ); vector<string> CBNET::AllFriendLocs();

bc4a3c0e0bd957a60bbdcdaef8e4d8bebcad44ba30fef57b4c2d3eb2cb864677