Datasets:

ssuresh

/

HPC_corpus_sub

like 0

cran

rgl

src/subscene.cpp

Subscene::hideViewpoint

void Subscene::hideViewpoint(int id) { if (userviewpoint && sameID(userviewpoint, id)) { if (parent) userviewpoint = NULL; } else if (modelviewpoint && sameID(modelviewpoint, id)) { if (parent) modelviewpoint = NULL; } }

Subscene::~Subscene(); bool Subscene::add(SceneNode* node); void Subscene::addBackground(Background* newbackground); void Subscene::addBBoxDeco(BBoxDeco* newbboxdeco); void Subscene::addShape(Shape* shape); void Subscene::addBBox(const AABox& bbox, bool changes); void Subscene::addLight(Light* light); void Subscene::addSubscene(Subscene* subscene); void Subscene::hideShape(int id); void Subscene::hideLight(int id); void Subscene::hideBBoxDeco(int id); void Subscene::hideBackground(int id); Subscene* Subscene::hideSubscene(int id, Subscene* current); Subscene* Subscene::getSubscene(int id); Subscene* Subscene::whichSubscene(int id); Subscene* Subscene::whichSubscene(int mouseX, int mouseY); int Subscene::getAttributeCount(SceneNode* subscene, AttribID attrib); void Subscene::getAttribute(SceneNode* subscene, AttribID attrib, int first, int count, double* result); String Subscene::getTextAttribute(SceneNode* subscene, AttribID attrib, int index); void Subscene::renderClipplanes(RenderContext* renderContext); void Subscene::disableClipplanes(RenderContext* renderContext); int Subscene::get_id_count(TypeID type, bool recursive); int Subscene::get_ids(TypeID type, int* ids, char** types, bool recursive); Background* Subscene::get_background(); Background* Subscene::get_background(int id); BBoxDeco* Subscene::get_bboxdeco(); BBoxDeco* Subscene::get_bboxdeco(int id); UserViewpoint* Subscene::getUserViewpoint(); ModelViewpoint* Subscene::getModelViewpoint(); void Subscene::update(RenderContext* renderContext); void Subscene::loadMatrices(); void Subscene::render(RenderContext* renderContext, bool opaquePass); void Subscene::calcDataBBox(); void Subscene::intersectClipplanes(void); void Subscene::newBBox(void); void Subscene::setIgnoreExtent(int in_ignoreExtent); void Subscene::setupViewport(RenderContext* rctx); void Subscene::setupProjMatrix(RenderContext* rctx); void Subscene::setupModelViewMatrix(RenderContext* rctx); void Subscene::setupModelMatrix(RenderContext* rctx); Sphere Subscene::getViewSphere(); void Subscene::disableLights(RenderContext* rctx); void Subscene::setupLights(RenderContext* rctx); void Subscene::renderUnsorted(RenderContext* renderContext); void Subscene::renderZsort(RenderContext* renderContext); const AABox& Subscene::getBoundingBox(); void Subscene::newEmbedding(); void Subscene::setEmbedding(int which, Embedding value); Embedding Subscene::getEmbedding(Embedded which); Subscene* Subscene::getMaster(Embedded which); void Subscene::getUserMatrix(double* dest); void Subscene::setUserMatrix(double* src); void Subscene::getUserProjection(double* dest); void Subscene::setUserProjection(double* src); void Subscene::getScale(double* dest); void Subscene::setScale(double* src); void Subscene::getPosition(double* dest); void Subscene::setPosition(double* src); void Subscene::setViewport(double x, double y, double width, double height); void Subscene::clearMouseListeners(); void Subscene::addMouseListener(Subscene* sub); void Subscene::deleteMouseListener(Subscene* sub); void Subscene::getMouseListeners(size_t max, int* ids); float Subscene::getDistance(const Vertex& v); viewControlPtr Subscene::getButtonBeginFunc(int button); void Subscene::buttonBegin(int button, int mouseX, int mouseY); viewControlPtr Subscene::getButtonUpdateFunc(int button); void Subscene::buttonUpdate(int button, int mouseX, int mouseY); viewControlEndPtr Subscene::getButtonEndFunc(int button); void Subscene::buttonEnd(int button); void Subscene::setDefaultMouseMode(); bool Subscene::mouseNeedsWatching(); void Subscene::setMouseMode(int button, MouseModeID mode); MouseModeID Subscene::getMouseMode(int button); void Subscene::setWheelCallback(userWheelPtr wheel, void* user); void Subscene::getWheelCallback(userWheelPtr *wheel, void** user); static PolarCoord screenToPolar(int width, int height, int mouseX, int mouseY); static Vertex screenToVector(int width, int height, int mouseX, int mouseY); void Subscene::trackballBegin(int mouseX, int mouseY); void Subscene::trackballUpdate(int mouseX, int mouseY); void Subscene::trackballEnd(); void Subscene::oneAxisBegin(int mouseX, int mouseY); void Subscene::oneAxisUpdate(int mouseX, int mouseY); void Subscene::polarBegin(int mouseX, int mouseY); void Subscene::polarUpdate(int mouseX, int mouseY); void Subscene::polarEnd(); void Subscene::adjustFOVBegin(int mouseX, int mouseY); void Subscene::adjustFOVUpdate(int mouseX, int mouseY); void Subscene::adjustFOVEnd(); void Subscene::wheelRotatePull(int dir); void Subscene::wheelRotatePush(int dir); void Subscene::wheelRotate(int dir); void Subscene::userBegin(int mouseX, int mouseY); void Subscene::userUpdate(int mouseX, int mouseY); void Subscene::userEnd(); void Subscene::userWheel(int dir); void Subscene::adjustZoomBegin(int mouseX, int mouseY); void Subscene::adjustZoomUpdate(int mouseX, int mouseY); void Subscene::adjustZoomEnd(); double* Subscene::getMousePosition(); MouseSelectionID Subscene::getSelectState(); void Subscene::setSelectState(MouseSelectionID state); void Subscene::mouseSelectionBegin(int mouseX,int mouseY); void Subscene::mouseSelectionUpdate(int mouseX,int mouseY); void Subscene::mouseSelectionEnd(); Subscene* Subscene::getRootSubscene();

0400076bd29b49f873dfdf4f8edefe98f514e9a74ca58baab9aacc4adc3acc0c

AscNHalf

AscNHalf

src/ascnhalf-world/WayPoints.cpp

ChatHandler::HandleWPChangeNoCommand

bool ChatHandler::HandleWPChangeNoCommand(const char* args, WorldSession *m_session) { uint64 guid = m_session->GetPlayer()->GetSelection(); if (guid == 0) { SystemMessage(m_session, "No selection."); return true; } if(GET_TYPE_FROM_GUID(guid) != HIGHGUID_TYPE_WAYPOINT) { SystemMessage(m_session, "You should select a Waypoint."); return true; } Player* pPlayer = m_session->GetPlayer(); AIInterface* ai = pPlayer->waypointunit; if(!ai || !ai->GetUnit()) { SystemMessage(m_session, "Invalid Creature, please select another one."); return true; } std::stringstream ss; char* pNewID = strtok((char*)args, " "); uint32 NewID = (pNewID)? atoi(pNewID) : 0; uint32 wpid = GUID_LOPART(guid); if(NewID == wpid) return false; if(wpid) { bool show = ai->m_WayPointsShowing; if(show == true) ai->hideWayPoints(pPlayer); ai->changeWayPointID(wpid,NewID); if(show == true) ai->showWayPoints(pPlayer,ai->m_WayPointsShowBackwards); ss << "Waypoint " << wpid << " changed to Waypoint " << NewID << "."; SystemMessage(m_session, ss.str().c_str()); } else { SystemMessage(m_session, "Invalid Waypoint."); return true; } return true; }

bool ChatHandler::HandleWPAddCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPMoveTypeCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPShowCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPDeleteCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPFlagsCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPMoveHereCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPWaitCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWaypointGettextCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWaypointForwardTextCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWaypointBackwardTextCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPSpellToCastCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPStandStateCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPEmoteCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPSkinCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPInfoCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleWPHideCommand(const char* args, WorldSession *m_session); bool ChatHandler::HandleGenerateWaypoints(const char* args, WorldSession * m_session); bool ChatHandler::HandleSaveWaypoints(const char* args, WorldSession * m_session); bool ChatHandler::HandleDeleteWaypoints(const char* args, WorldSession * m_session); bool ChatHandler::HandleWaypointAddFlyCommand(const char * args, WorldSession * m_session); bool ChatHandler::HandleNpcSelectCommand(const char * args, WorldSession * m_session);

9405b7bd9d2e6f9bac04c9fec0666df3bd521cbbb21ea8dfcc09af60a966a32b

BlazesRus

niflib

src/obj/NiBinaryExtraData.cpp

NiBinaryExtraData::Write

void NiBinaryExtraData::Write(ostream& out, const map<NiObjectRef, unsigned int> & link_map, list<NiObject *> & missing_link_stack, const NifInfo & info) const { NiExtraData::Write(out, link_map, missing_link_stack, info); binaryData.dataSize = (unsigned int) (binaryData.data.size()); NifStream(binaryData.dataSize, out, info); for(unsigned int i1 = 0; i1 < binaryData.data.size(); i1++) { NifStream(binaryData.data[i1], out, info); }; }

NiBinaryExtraData::NiBinaryExtraData(); NiBinaryExtraData::~NiBinaryExtraData(); const Type & NiBinaryExtraData::GetType(); NiObject * NiBinaryExtraData::Create(); void NiBinaryExtraData::Read(istream& in, list<unsigned int> & link_stack, const NifInfo & info); std::string NiBinaryExtraData::asString(bool verbose); void NiBinaryExtraData::FixLinks(const map<unsigned int, NiObjectRef> & objects, list<unsigned int> & link_stack, list<NiObjectRef> & missing_link_stack, const NifInfo & info); std::list<NiObjectRef> NiBinaryExtraData::GetRefs(); std::list<NiObject *> NiBinaryExtraData::GetPtrs(); vector<byte> NiBinaryExtraData::GetData(); void NiBinaryExtraData::SetData(const vector<byte> & n);

a83c60bb7e85de4f1ad6432b2a04f345a1447a68b73820a2db0d9e1461f557cc

CarlosManuelRodr

wxChaos

libs/wxMSW-3.1.4/src/gtk/renderer.cpp

int wxRendererGTK::DrawHeaderButton

int wxRendererGTK::DrawHeaderButton(wxWindow *win, wxDC& dc, const wxRect& rect, int flags, wxHeaderSortIconType sortArrow, wxHeaderButtonParams* params) { GtkWidget *button = wxGTKPrivate::GetHeaderButtonWidget(); if (flags & wxCONTROL_SPECIAL) button = wxGTKPrivate::GetHeaderButtonWidgetFirst(); if (flags & wxCONTROL_DIRTY) button = wxGTKPrivate::GetHeaderButtonWidgetLast(); int x_diff = 0; if (win->GetLayoutDirection() == wxLayout_RightToLeft) x_diff = rect.width; GtkStateType state = GTK_STATE_NORMAL; if (flags & wxCONTROL_DISABLED) state = GTK_STATE_INSENSITIVE; else { if (flags & wxCONTROL_CURRENT) state = GTK_STATE_PRELIGHT; } #ifdef __WXGTK3__ cairo_t* cr = wxGetGTKDrawable(dc); if (cr == NULL) return 0; #if GTK_CHECK_VERSION(3,20,0) if (gtk_check_version(3,20,0) == NULL) { int pos = 1; if (flags & wxCONTROL_SPECIAL) pos = 0; if (flags & wxCONTROL_DIRTY) pos = 2; wxGtkStyleContext sc(dc.GetContentScaleFactor()); sc.AddTreeviewHeaderButton(pos); gtk_style_context_set_state(sc, stateTypeToFlags[state]); gtk_render_background(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height); gtk_render_frame(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height); } else #endif { GtkStyleContext* sc = gtk_widget_get_style_context(button); gtk_style_context_save(sc); gtk_style_context_set_state(sc, stateTypeToFlags[state]); gtk_render_background(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height); gtk_render_frame(sc, cr, rect.x - x_diff, rect.y, rect.width, rect.height); gtk_style_context_restore(sc); } #else GdkWindow* gdk_window = wxGetGTKDrawable(dc); gtk_paint_box ( gtk_widget_get_style(button), gdk_window, state, GTK_SHADOW_OUT, NULL, button, "button", dc.LogicalToDeviceX(rect.x) - x_diff, rect.y, rect.width, rect.height ); #endif return DrawHeaderButtonContents(win, dc, rect, flags, sortArrow, params); }

wxRendererNative& wxRendererNative::GetDefault(); static cairo_t* wxGetGTKDrawable(const wxDC& dc); static GdkWindow* wxGetGTKDrawable(wxDC& dc); int wxRendererGTK::GetHeaderButtonHeight(wxWindow *WXUNUSED(win); int wxRendererGTK::GetHeaderButtonMargin(wxWindow *WXUNUSED(win); static int GetGtkSplitterFullSize(GtkWidget* widget); CheckBoxInfo(wxGtkStyleContext& sc, int flags); CheckBoxInfo(GtkWidget* button, int flags); void FitInto(const wxRect& rect); void wxRendererGTK::DrawFocusRect(wxWindow* win, wxDC& dc, const wxRect& rect, int flags); void wxRendererGTK::DrawTextCtrl(wxWindow*, wxDC& dc, const wxRect& rect, int flags); void wxRendererGTK::DrawComboBox(wxWindow* win, wxDC& dc, const wxRect& rect, int flags); void wxRendererGTK::DrawRadioBitmap(wxWindow*, wxDC& dc, const wxRect& rect, int flags);

fe81bf43efa890075ea4bea05890265cedf12df61cf787484589a7b84d1eb8ba

BrandonSchaefer

xbmc

xbmc/network/test/TestWebServer.cpp

TEST_F

TEST_F(TestWebServer, CanGetRangedFileRangeFirst_Second) { const std::string rangedFileContent = TEST_FILES_DATA_RANGES; std::vector<std::string> rangedContent = StringUtils::Split(TEST_FILES_DATA_RANGES, ";"); const std::string range = GenerateRangeHeaderValue(rangedContent.front().size() + 1, rangedContent.front().size() + 1 + rangedContent.at(2).size() - 1); CHttpRanges ranges; ASSERT_TRUE(ranges.Parse(range, rangedFileContent.size())); std::string result; CCurlFile curl; curl.SetRequestHeader(MHD_HTTP_HEADER_RANGE, range); ASSERT_TRUE(curl.Get(GetUrlOfTestFile(TEST_FILES_RANGES), result)); CheckRangesTestFileResponse(curl, result, ranges); }

TestWebServer(); virtual void SetUp(); virtual void TearDown(); void SetupMediaSources(); void TearDownMediaSources(); std::string GetUrl(const std::string& path); std::string GetUrlOfTestFile(const std::string& testFile); bool GetLastModifiedOfTestFile(const std::string& testFile, CDateTime& lastModified); void CheckHtmlTestFileResponse(const CCurlFile& curl); void CheckRangesTestFileResponse(const CCurlFile& curl, int httpStatus = MHD_HTTP_OK, bool empty = false); void CheckRangesTestFileResponse(const CCurlFile& curl, const std::string& result, const CHttpRanges& ranges); std::string GenerateRangeHeaderValue(unsigned int start, unsigned int end); TEST_F(TestWebServer, IsStarted); TEST_F(TestWebServer, CanGetJsonRpcApiDescription); TEST_F(TestWebServer, CanGetJsonRpcResponse); TEST_F(TestWebServer, CanNotHeadNonExistingFile); TEST_F(TestWebServer, CanHeadFile); TEST_F(TestWebServer, CanNotGetNonExistingFile); TEST_F(TestWebServer, CanGetFile); TEST_F(TestWebServer, CanGetFileForcingNoCache); TEST_F(TestWebServer, CanGetCachedFileWithOlderIfModifiedSince); TEST_F(TestWebServer, CanGetCachedFileWithNewerIfModifiedSinceForcingNoCache); TEST_F(TestWebServer, CanGetCachedFileWithOlderIfUnmodifiedSince); TEST_F(TestWebServer, CanGetCachedFileWithExactIfUnmodifiedSince); TEST_F(TestWebServer, CanGetCachedFileWithNewerIfUnmodifiedSince); TEST_F(TestWebServer, CanGetRangedFileRange0_); TEST_F(TestWebServer, CanGetRangedFileRange0_End); TEST_F(TestWebServer, CanGetRangedFileRange0_2xEnd); TEST_F(TestWebServer, CanGetRangedFileRange0_First); TEST_F(TestWebServer, CanGetRangedFileRange_Last); TEST_F(TestWebServer, CanGetRangedFileRangeFirstSecond); TEST_F(TestWebServer, CanGetRangedFileRangeFirstSecondLast); TEST_F(TestWebServer, CanGetCachedRangedFileWithOlderIfRange); TEST_F(TestWebServer, CanGetCachedRangedFileWithExactIfRange); TEST_F(TestWebServer, CanGetCachedRangedFileWithNewerIfRange);

7dd49d51aab5b1fe2e2a27217a2b5e07d0696e01a639d3b34480709c3361a09a

vldtecno

PTN-Engine

Examples/Elevator/Controller/ElevatorController.cpp

ElevatorController::increaseFloor

void ElevatorController::increaseFloor() { cout << "Ascending... " << endl; ++m_currentFloor; printCurrentFloor(); }

ElevatorController::ElevatorController(); ElevatorController::~ElevatorController(); void ElevatorController::initialize(); void ElevatorController::openDoors(); void ElevatorController::closeDoors(); bool ElevatorController::callElevatorUp(const int floor); bool ElevatorController::callElevatorDown(const int floor); bool ElevatorController::setDestinationFloor(const int floor); void ElevatorController::addDestination1(); void ElevatorController::addDestination2(); void ElevatorController::addWaitingToGoDown(); void ElevatorController::addWaitingToGoUp(); void ElevatorController::removeDestinationGU(); void ElevatorController::removeDestinationGD(); void ElevatorController::removeDestination(); void ElevatorController::removeCurrentFromWaitingToGoDown(); void ElevatorController::removeCurrentFromWaitingToGoUp(); void ElevatorController::rotateLists(); void ElevatorController::decreaseFloor(); void ElevatorController::mergeGoingUpGTCurrent(); void ElevatorController::mergeMinGoingUp(); void ElevatorController::mergeMaxGoingDown(); void ElevatorController::mergePostponedToCurrent(); void ElevatorController::mergeGoingDownSTCurrent(); void ElevatorController::mergeToDestinations(unordered_set<int>& toAdd, const bool lessThan); void ElevatorController::processedLists(); bool ElevatorController::isFloorNotInList(); bool ElevatorController::isFloorInList(); bool ElevatorController::isDestinationListNotEmpty(); bool ElevatorController::isDestinationListEmpty(); bool ElevatorController::isMarkedFloorNotCurrentFloor(); bool ElevatorController::isMarkedFloorGreaterThanCurrentFloor(); bool ElevatorController::isMarkedFloorSmallerThanCurrentFloor(); bool ElevatorController::isMinSmallerThanCurrent(); bool ElevatorController::isMinGreaterThanCurrent(); bool ElevatorController::isMaxSmallerThanCurrent(); bool ElevatorController::isMaxGreaterThanCurrent(); void ElevatorController::elevatorStopped(); void ElevatorController::elevatorMoving(); void ElevatorController::doorsAreOpen(); void ElevatorController::doorsAreClosed(); void ElevatorController::goingUp(); void ElevatorController::goingDown(); void ElevatorController::printCurrentFloor(); void ElevatorController::printDestinations(); void ElevatorController::printNextDestinations(); void ElevatorController::printWaitingGoDown(); void ElevatorController::printWaitingGoUp(); void ElevatorController::printFloorList(const unordered_set<int>& floors); void ElevatorController::printSchedule();

e91d179f1934b6cd8762b0208925e348b998e94d143bfdae48c212be1e431cf9

OxfordSKA

OSKAR

oskar/settings/types/src/oskar_IntListExt.cpp

IntListExt::init

bool IntListExt::init(const char* s) { if (!s || strlen(s) == 0) return false; special_value_ = string(s); default_ = special_value_; value_ = special_value_; return true; }

static bool compare(const IntListExt::Value& a, const IntListExt::Value& b); IntListExt::IntListExt(); IntListExt::~IntListExt(); bool IntListExt::set_default(const char* value); bool IntListExt::set_value(const char* value); bool IntListExt::is_default(); const char* IntListExt::special_string(); bool IntListExt::is_extended(); int IntListExt::size(); const int* IntListExt::values(); bool IntListExt::operator==(const IntListExt& other); bool IntListExt::operator>(const IntListExt&); bool IntListExt::from_string(const string& s, Value& val); string IntListExt::to_string(const Value& v);

54504b90a6022952b8cd38b7f24b7a519c2a44431d5d8ce23e9018a0d4b0dba1

mohsenti

DSPlayer

3rdParties/mediainfo/MediaInfoLib/Source/MediaInfo/Video/File_Vc3.cpp

File_Vc3::Synched_Test

bool File_Vc3::Synched_Test() { if (Buffer_Offset + 5 > Buffer_Size) return false; if (Buffer[Buffer_Offset] != 0x00 || Buffer[Buffer_Offset + 1] != 0x00 || Buffer[Buffer_Offset + 2] != 0x02 || Buffer[Buffer_Offset + 3] != 0x80 || Buffer[Buffer_Offset + 4] == 0x00) { Synched = false; return true; } return true; }

static const bool Vc3_FromCID_IsSupported(int32u CompressionID); static const int32u Vc3_CompressedFrameSize(int32u CompressionID); static const int8u Vc3_SBD(int32u SBD); static const int8u Vc3_SBD_FromCID(int32u CompressionID); static const char *Vc3_SST_FromCID(int32u CompressionID); static const int16u Vc3_SPL_FromCID(int32u CompressionID); static const int16u Vc3_ALPF_PerFrame_FromCID(int32u CompressionID); static const char *Vc3_CLR_FromCID(int32u CompressionID); static const char *Vc3_SSC_FromCID(int32u CompressionID); File_Vc3::File_Vc3(); File_Vc3::~File_Vc3(); void File_Vc3::Streams_Fill(); void File_Vc3::Streams_Finish(); bool File_Vc3::Synchronize(); bool File_Vc3::Demux_UnpacketizeContainer_Test(); void File_Vc3::Read_Buffer_Unsynched(); bool File_Vc3::Header_Begin(); void File_Vc3::Header_Parse(); void File_Vc3::Data_Parse(); void File_Vc3::HeaderPrefix(); void File_Vc3::CodingControlA(); void File_Vc3::ImageGeometry(); void File_Vc3::CompressionID(); void File_Vc3::CodingControlB(); void File_Vc3::TimeCode(); void File_Vc3::UserData(); void File_Vc3::UserData_8();

dc4eabdbaa24fc56eba85dd98c2712537cbd4fb24a2eae49dacd7e9067fabcf5

nielsbasjes

SuckMT

nt.cpp

void omni_thread::start

void omni_thread::start(void) { omni_mutex_lock l(mutex); if (_state != STATE_NEW) throw omni_thread_invalid(); #ifndef __BCPLUSPLUS__ unsigned int t; handle = (HANDLE)_beginthreadex( NULL, 0, omni_thread_wrapper, (LPVOID)this, CREATE_SUSPENDED, &t); nt_id = t; if (handle == NULL) throw omni_thread_fatal(GetLastError()); #else handle = (HANDLE)_beginthreadNT(omni_thread_wrapper, 0, (void*)this, NULL, CREATE_SUSPENDED, &nt_id); if (handle == INVALID_HANDLE_VALUE) throw omni_thread_fatal(errno); #endif if (!SetThreadPriority(handle, nt_priority(_priority))) throw omni_thread_fatal(GetLastError()); if (ResumeThread(handle) == 0xffffffff) throw omni_thread_fatal(GetLastError()); _state = STATE_RUNNING; }

omni_mutex::omni_mutex(void); omni_mutex::~omni_mutex(void); inline _internal_omni_thread_helper(); inline ~_internal_omni_thread_helper(); omni_condition::omni_condition(omni_mutex* m); omni_condition::~omni_condition(void); omni_semaphore::omni_semaphore(unsigned int initial); omni_semaphore::~omni_semaphore(void); omni_thread::init_t::init_t(void); omni_thread_wrapper(void* ptr); omni_thread::omni_thread(void (*fn); omni_thread::omni_thread(void* (*fn); omni_thread::omni_thread(void* arg, priority_t pri); omni_thread::~omni_thread(void);

fc62c324ed717dc390a7f40943ef07e7d2f38e1bb2c48c61ddeac7a5b1ae60b4

soulik

LuaBox2D

src/objects/RevoluteJoint.cpp

RevoluteJoint::getUserData

inline int RevoluteJoint::getUserData(State & state, b2RevoluteJoint * object){ return base->getUserData(state, object); }

void initRevoluteJoint(State * state); b2RevoluteJoint * RevoluteJoint::constructor(State & state, bool & managed); void RevoluteJoint::destructor(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::getType(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::getBodyA(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::getBodyB(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::setUserData(State & state, b2RevoluteJoint * object); int RevoluteJoint::getAnchorA(State & state, b2RevoluteJoint * object); int RevoluteJoint::getAnchorB(State & state, b2RevoluteJoint * object); int RevoluteJoint::getReactionForce(State & state, b2RevoluteJoint * object); int RevoluteJoint::getReactionTorque(State & state, b2RevoluteJoint * object); int RevoluteJoint::getMotorTorque(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::getActive(State & state, b2RevoluteJoint * object); inline int RevoluteJoint::getCollideConnected(State & state, b2RevoluteJoint * object); int RevoluteJoint::getLocalAnchorA(State & state, b2RevoluteJoint * object); int RevoluteJoint::getLocalAnchorB(State & state, b2RevoluteJoint * object); int RevoluteJoint::getReferenceAngle(State & state, b2RevoluteJoint * object); int RevoluteJoint::getEnableLimit(State & state, b2RevoluteJoint * object); int RevoluteJoint::setEnableLimit(State & state, b2RevoluteJoint * object); int RevoluteJoint::getLowerLimit(State & state, b2RevoluteJoint * object); int RevoluteJoint::getUpperLimit(State & state, b2RevoluteJoint * object); int RevoluteJoint::setLimits(State & state, b2RevoluteJoint * object); int RevoluteJoint::getEnableMotor(State & state, b2RevoluteJoint * object); int RevoluteJoint::setEnableMotor(State & state, b2RevoluteJoint * object); int RevoluteJoint::getMotorSpeed(State & state, b2RevoluteJoint * object); int RevoluteJoint::setMotorSpeed(State & state, b2RevoluteJoint * object); int RevoluteJoint::getMaxMotorTorque(State & state, b2RevoluteJoint * object); int RevoluteJoint::setMaxMotorTorque(State & state, b2RevoluteJoint * object);

a66576436327067860b3ec77b37676d69474d9336ccfaf87410c43c6b27fbb4a

plewis

phycas

src/cpp/partition_model.cpp

PartitionModel::getSubsetProportions

SubsetProportionsShPtr PartitionModel::getSubsetProportions() { return _subset_proportions; }

PartitionModel::PartitionModel(); PartitionModel::~PartitionModel(); void PartitionModel::createJointPriorManager(); unsigned PartitionModel::getNumSubsets(); unsigned PartitionModel::getTotalNumPatterns(); unsigned PartitionModel::getTotalNumSites(); const ModelVect & PartitionModel::getModelsVect(); double PartitionModel::getSubsetRelRate(unsigned i); const std::vector<double> & PartitionModel::getSubsetRelRatesVect(); MultivarProbDistShPtr PartitionModel::getSubsetRelRatePrior(); void PartitionModel::debugShowTransformedRelativeRates(const std::string msg); const std::vector<unsigned> & PartitionModel::getNumPatternsVect(); unsigned PartitionModel::getNumSites(unsigned i); const std::vector<unsigned> & PartitionModel::getNumSitesVect(); const std::vector<unsigned> & PartitionModel::getNumStatesVect(); const std::vector<unsigned> & PartitionModel::getNumRatesVect(); void PartitionModel::addModel(ModelShPtr m); void PartitionModel::setModelsVect(const ModelVect & models); void PartitionModel::setNumPatternsVect(const std::vector<unsigned> & npatterns); void PartitionModel::setNumSitesVect(const std::vector<unsigned> & nsites); void PartitionModel::setNumStatesVect(const std::vector<unsigned> & nstates); void PartitionModel::setNumRatesVect(const std::vector<unsigned> & nrates); void PartitionModel::setSiteAssignments(const std::vector<unsigned> & v); const std::vector<unsigned> & PartitionModel::getSiteAssignments(); unsigned PartitionModel::getNumFreeParameters(); std::vector<std::string> PartitionModel::getPWKParameterNames(); std::vector<std::string> PartitionModel::getFreeParameterNames(); std::vector<std::string> PartitionModel::getAllParameterNames(); void PartitionModel::appendUntransformedSubsetRelativeRates(std::vector<double> & values); void PartitionModel::appendTransformedSubsetRelativeRates(std::vector<double> & values); double PartitionModel::calcLogDetJacobian(); std::vector<double> PartitionModel::getUntransformedParameters(); std::vector<double> PartitionModel::getTransformedParameters(); double PartitionModel::getLogDetJacobian(); JointPriorManagerShPtr PartitionModel::getJointPriorManager();

9c38c9f840957855cc87a5c77f61113ffd7b8580b94883398fc62df64f8b9d71

Zuppka

RLG

src/modules/fileman.cpp

makeDir

bool makeDir(std::string path) { struct stat info; if (stat (path.c_str(), &info) != 0) { printf("Creating directory \"%s\"...\n", path.c_str()); CreateDirectory(path.c_str(), NULL); return true; } return false; }

bool makeFile(std::string name); bool Fileman::readFile(std::string path); bool Fileman::writeFile(std::string path);

fba4592901de84b1b47785d20b49e26dec420cc7a68ce94aac4a78a14ff5af5f

bloomberg

bde

groups/bsl/bslalg/bslalg_nothrowmovableutil.t.cpp

SomeType

SomeType(int v = 0) : d_value(v) { }

void aSsErT(bool condition, const char *message, int line); TrackableValue(int v = 0); TrackableValue(const TrackableValue& original); TrackableValue(bslmf::MovableRef<TrackableValue> original); TrackableValue& operator=(int v); TrackableValue& operator=(const TrackableValue& rhs); void resetMoveCopiedFlags(); void TrackableValue::swap(TrackableValue& other); void TrackableValue::setIsCopiedRaw(bool copiedFlag); void TrackableValue::setIsMovedRaw(bool movedFlag); void TrackableValue::setValueRaw(int v); explicit TrackableValueWithAlloc(int v = 0); explicit TrackableValueWithAlloc(const allocator_type& alloc); TrackableValueWithAlloc(int v, const allocator_type& alloc); TrackableValueWithAlloc( bslmf::MovableRef<TrackableValueWithAlloc> original); TrackableValueWithAlloc& operator=(const TrackableValueWithAlloc& rhs); TrackableValueWithAlloc& operator=( bslmf::MovableRef<TrackableValueWithAlloc> rhs); void resetMoveCopiedFlags(); CountedType<TYPE>::CountedType(const TYPE& val); CountedType<TYPE>::CountedType(const CountedType& original); CountedType<TYPE>::CountedType(bslmf::MovableRef<CountedType> original); SomeType(const SomeType& original); SomeType(bslmf::MovableRef<SomeType> original); CountedType2(const TYPE& val); CountedType2(const CountedType2& original); CountedType2(bslmf::MovableRef<CountedType2> original); ValueType& value(); const ValueType& value(); void usageExample(); bool checkAllocator(const TYPE& obj, const bsl::allocator<char>& allocator); bool hasSameAllocator(const TYPE& obj1, const TYPE& obj2); void TestDriver<TYPE>::testCase4(); void TestDriver<TYPE>::testCase3(); int main(int argc, char *argv[]);

fc95ac11093794636a766021680f133e13a7a36f33ef81c3cdeead06edf2bd22

ibrarahmad

cstore

src/UnitTests/DVTest.cpp

DVTest::runTestCase4

bool DVTest::runTestCase4(Globals* g, const vector<string>& args) { bool success = true; WOSManager* wm = new WOSManager(DVTEST_PROJECTION_NAME, 2, 1 ); wm->deleteTuple( 5, true ); wm->deleteTuple( 4, true ); wm->deleteTuple( 100, true ); wm->deleteTuple( 99, true ); wm->deleteTuple( 88, true ); wm->deleteTuple( 12, true ); wm->deleteTuple( 50, true ); IntDataSource *ds1 = new IntDataSource( wm->getDVAM( true ), true, false); Operator* srcs[1]={ ds1 }; int numCols[1]={1}; system ("rm DVTest_ROS.out"); BlockPrinter* bPrint = new BlockPrinter(srcs, numCols, 1, "DVTest_ROS.out"); bPrint->printColumnsWithPosition(); delete bPrint; delete wm; return success; }

DVTest::DVTest(); DVTest::~DVTest(); bool DVTest::run(Globals* g, const vector<string>& args); bool DVTest::runTestCase1(Globals* g, const vector<string>& args); bool DVTest::runTestCase2(Globals* g, const vector<string>& args); bool DVTest::runTestCase3(Globals* g, const vector<string>& args); void DVTest::makeData(Globals* g, const vector<string>& args);

0e7afe438fa01f841487d1cf6b993fe06dbcb4d0623e203a4f70cb5f91193def

PGer

incubator-hawq

depends/libyarn/src/rpc/RpcChannel.cpp

RpcChannelImpl::cleanupPendingCalls

void RpcChannelImpl::cleanupPendingCalls(exception_ptr reason) { assert(!writeMut.try_lock()); unordered_map<int32_t, RpcRemoteCallPtr>::iterator s, e; e = pendingCalls.end(); for (s = pendingCalls.begin(); s != e; ++s) { s->second->cancel(reason); } pendingCalls.clear(); }

RpcChannelImpl::RpcChannelImpl(const RpcChannelKey & k, RpcClient & c); RpcChannelImpl::~RpcChannelImpl(); void RpcChannelImpl::close(bool immediate); void RpcChannelImpl::sendSaslMessage(hadoop::common::RpcSaslProto * msg, Message * resp); std::string RpcChannelImpl::saslEvaluateToken(hadoop::common::RpcSaslProto & response, bool serverIsDone); RpcAuth RpcChannelImpl::setupSaslConnection(); void RpcChannelImpl::connect(); exception_ptr RpcChannelImpl::invokeInternal(RpcRemoteCallPtr remote); void RpcChannelImpl::invoke(const RpcCall & call); void RpcChannelImpl::shutdown(exception_ptr reason); void RpcChannelImpl::wakeupOneCaller(int32_t id); void RpcChannelImpl::sendRequest(RpcRemoteCallPtr remote); void RpcChannelImpl::checkOneResponse(); void RpcChannelImpl::sendPing(); bool RpcChannelImpl::checkIdle(); void RpcChannelImpl::waitForExit(); void RpcChannelImpl::sendConnectionHeader(const RpcAuth &auth); void RpcChannelImpl::sendConnectionContent(const RpcAuth & auth); RpcRemoteCallPtr RpcChannelImpl::getPendingCall(int32_t id); bool RpcChannelImpl::getResponse(); static exception_ptr HandlerRpcResponseException(exception_ptr e); void RpcChannelImpl::readOneResponse(bool writeLock);

3493d5ef5cc3942214594ed92e3ec34e6a4d2f33c9c6c4930a7c5aa1ac750d5d

reboot

obs-studio

UI/volume-control.cpp

VolumeMeter::setMajorTickColor

void VolumeMeter::setMajorTickColor(QColor c) { majorTickColor = c; }

void VolControl::OBSVolumeChanged(void *data, float db); void VolControl::OBSVolumeMuted(void *data, calldata_t *calldata); void VolControl::VolumeChanged(); void VolControl::VolumeMuted(bool muted); void VolControl::SetMuted(bool checked); void VolControl::SliderChanged(int vol); void VolControl::updateText(); QString VolControl::GetName(); void VolControl::SetName(const QString &newName); void VolControl::EmitConfigClicked(); void VolControl::SetMeterDecayRate(qreal q); VolControl::VolControl(OBSSource source_, bool showConfig); VolControl::~VolControl(); QColor VolumeMeter::getBackgroundNominalColor(); void VolumeMeter::setBackgroundNominalColor(QColor c); QColor VolumeMeter::getBackgroundWarningColor(); void VolumeMeter::setBackgroundWarningColor(QColor c); QColor VolumeMeter::getBackgroundErrorColor(); void VolumeMeter::setBackgroundErrorColor(QColor c); QColor VolumeMeter::getForegroundNominalColor(); void VolumeMeter::setForegroundNominalColor(QColor c); QColor VolumeMeter::getForegroundWarningColor(); void VolumeMeter::setForegroundWarningColor(QColor c); QColor VolumeMeter::getForegroundErrorColor(); void VolumeMeter::setForegroundErrorColor(QColor c); QColor VolumeMeter::getClipColor(); void VolumeMeter::setClipColor(QColor c); QColor VolumeMeter::getMagnitudeColor(); void VolumeMeter::setMagnitudeColor(QColor c); QColor VolumeMeter::getMajorTickColor(); QColor VolumeMeter::getMinorTickColor(); void VolumeMeter::setMinorTickColor(QColor c); qreal VolumeMeter::getMinimumLevel(); void VolumeMeter::setMinimumLevel(qreal v); qreal VolumeMeter::getWarningLevel(); void VolumeMeter::setWarningLevel(qreal v); qreal VolumeMeter::getErrorLevel(); void VolumeMeter::setErrorLevel(qreal v); qreal VolumeMeter::getClipLevel(); void VolumeMeter::setClipLevel(qreal v); qreal VolumeMeter::getMinimumInputLevel(); void VolumeMeter::setMinimumInputLevel(qreal v); qreal VolumeMeter::getPeakDecayRate(); void VolumeMeter::setPeakDecayRate(qreal v); qreal VolumeMeter::getMagnitudeIntegrationTime(); void VolumeMeter::setMagnitudeIntegrationTime(qreal v); qreal VolumeMeter::getPeakHoldDuration(); void VolumeMeter::setPeakHoldDuration(qreal v); qreal VolumeMeter::getInputPeakHoldDuration(); void VolumeMeter::setInputPeakHoldDuration(qreal v); VolumeMeter::VolumeMeter(QWidget *parent, obs_volmeter_t *obs_volmeter); VolumeMeter::~VolumeMeter(); inline void VolumeMeter::resetLevels(); inline void VolumeMeter::handleChannelCofigurationChange(); inline bool VolumeMeter::detectIdle(uint64_t ts); void VolumeMeter::paintEvent(QPaintEvent *event); void VolumeMeterTimer::AddVolControl(VolumeMeter *meter); void VolumeMeterTimer::RemoveVolControl(VolumeMeter *meter); void VolumeMeterTimer::timerEvent(QTimerEvent*);

dc4275751a1280a7125bde37c31635aa4f98726d4c1b4fac73ee25a48e1d2908

mworks

mworks

core/Core/ParadigmComponents/TrialBuildingBlocks.cpp

IfElse::execute

bool IfElse::execute() { if (conditionals.empty()) { mwarning(M_PARADIGM_MESSAGE_DOMAIN, "if/else contains no conditional (if) actions"); } for (auto &cond : conditionals) { if (cond->execute()) { return true; } } if (unconditional) { unconditional->execute(); } return false; }

void Action::describeComponent(ComponentInfo &info); Action::Action(const ParameterValueMap &parameters); Action::Action(); bool Action::execute(); void Action::action(); void Action::announceEntry(); void Action::setName(const std::string &_name); ActionVariableNotification::ActionVariableNotification(shared_ptr<Action> _action); void ActionVariableNotification::notify(const Datum& data, MWTime time); void Assignment::describeComponent(ComponentInfo &info); Assignment::Assignment(const ParameterValueMap &parameters); Assignment::Assignment(const VariablePtr &var, const VariablePtr &value); bool Assignment::execute(); void ReportString::describeComponent(ComponentInfo &info); ReportString::ReportString(const ParameterValueMap &parameters); bool ReportString::execute(); void AssertionAction::describeComponent(ComponentInfo &info); AssertionAction::AssertionAction(const ParameterValueMap &parameters); bool AssertionAction::execute(); SetTimeBase::SetTimeBase(shared_ptr<TimeBase> _timebase); bool SetTimeBase::execute(); void TimerAction::describeComponent(ComponentInfo &info); TimerAction::TimerAction(const ParameterValueMap &parameters); MWTime TimerAction::getExpirationTime(); void StartTimer::describeComponent(ComponentInfo &info); StartTimer::StartTimer(const ParameterValueMap &parameters); bool StartTimer::execute(); void Wait::describeComponent(ComponentInfo &info); Wait::Wait(const ParameterValueMap &parameters); bool Wait::execute(); weak_ptr<State> Wait::next(); void WaitForCondition::describeComponent(ComponentInfo &info); WaitForCondition::WaitForCondition(const ParameterValueMap &parameters); bool WaitForCondition::execute(); weak_ptr<State> WaitForCondition::next(); bool WaitForCondition::stillWaiting(); bool LoadStimulus::execute(); bool UnloadStimulus::execute(); bool QueueStimulus::execute(); LiveQueueStimulus::~LiveQueueStimulus(); bool LiveQueueStimulus::execute(); DequeueStimulus::DequeueStimulus(shared_ptr<StimulusNode> _stimnode); bool DequeueStimulus::execute(); bool BringStimulusToFront::execute(); shared_ptr<StimulusNode> BringStimulusToFront::getStimulusNode(); bool SendStimulusToBack::execute(); shared_ptr<StimulusNode> SendStimulusToBack::getStimulusNode(); void StimulusDisplayAction::describeComponent(ComponentInfo &info); StimulusDisplayAction::StimulusDisplayAction(const ParameterValueMap &parameters); bool StimulusDisplayAction::execute(); weak_ptr<State> StimulusDisplayAction::next(); bool StimulusDisplayAction::stillWaiting(); void UpdateStimulusDisplay::describeComponent(ComponentInfo &info); UpdateStimulusDisplay::UpdateStimulusDisplay(const ParameterValueMap &parameters); boost::shared_ptr<StimulusDisplay::UpdateInfo> UpdateStimulusDisplay::performAction(); const char * UpdateStimulusDisplay::getActionName(); void ClearStimulusDisplay::describeComponent(ComponentInfo &info); ClearStimulusDisplay::ClearStimulusDisplay(const ParameterValueMap &parameters); boost::shared_ptr<StimulusDisplay::UpdateInfo> ClearStimulusDisplay::performAction(); const char * ClearStimulusDisplay::getActionName(); void SoundAction::describeComponent(ComponentInfo &info); SoundAction::SoundAction(const ParameterValueMap &parameters); void LoadSound::describeComponent(ComponentInfo &info); LoadSound::LoadSound(const ParameterValueMap &parameters); bool LoadSound::execute(); void UnloadSound::describeComponent(ComponentInfo &info); UnloadSound::UnloadSound(const ParameterValueMap &parameters); bool UnloadSound::execute(); void PlaySound::describeComponent(ComponentInfo &info); PlaySound::PlaySound(const ParameterValueMap &parameters); bool PlaySound::execute(); void PauseSound::describeComponent(ComponentInfo &info); PauseSound::PauseSound(const ParameterValueMap &parameters); bool PauseSound::execute(); void StopSound::describeComponent(ComponentInfo &info); StopSound::StopSound(const ParameterValueMap &parameters); bool StopSound::execute(); StartDeviceIO::StartDeviceIO(shared_ptr<IODevice> _device); bool StartDeviceIO::execute(); StopDeviceIO::StopDeviceIO(shared_ptr<IODevice> _device); bool StopDeviceIO::execute(); void If::describeComponent(ComponentInfo &info); If::If(const ParameterValueMap &parameters); If::If(const VariablePtr &condition); void If::addAction(const boost::shared_ptr<Action> &action); bool If::execute(); void Else::describeComponent(ComponentInfo &info); Else::Else(const ParameterValueMap &parameters); bool Else::execute(); void IfElse::describeComponent(ComponentInfo &info); IfElse::IfElse(const ParameterValueMap &parameters); void While::describeComponent(ComponentInfo &info); While::While(const ParameterValueMap &parameters); bool While::execute(); boost::weak_ptr<State> While::next(); bool While::performIteration(); TransitionCondition::TransitionCondition(weak_ptr<State> trans); TransitionCondition::~TransitionCondition(); weak_ptr<State> TransitionCondition::execute(); void TransitionCondition::setOwner(weak_ptr<State> _owner); weak_ptr<State> TransitionCondition::getOwner(); weak_ptr<State> TransitionCondition::getTransition(); weak_ptr<State> TransitionIfTimerExpired::execute(); YieldToParent::YieldToParent(); YieldToParent::~YieldToParent(); weak_ptr<State> YieldToParent::execute(); void TaskSystemState::describeComponent(ComponentInfo &info); TaskSystemState::TaskSystemState(); TaskSystemState::TaskSystemState(const ParameterValueMap &parameters); shared_ptr<mw::Component> TaskSystemState::createInstanceObject(); weak_ptr<State> TaskSystemState::next(); void TaskSystemState::reset(); void TaskSystemState::addTransition(shared_ptr<TransitionCondition> trans); void TaskSystem::describeComponent(ComponentInfo &info); TaskSystem::TaskSystem(); TaskSystem::TaskSystem(const ParameterValueMap &parameters); shared_ptr<mw::Component> TaskSystem::createInstanceObject(); void TaskSystem::action(); weak_ptr<State> TaskSystem::next(); void StopExperiment::describeComponent(ComponentInfo &info); StopExperiment::StopExperiment(const ParameterValueMap &parameters); bool StopExperiment::execute(); void PauseExperiment::describeComponent(ComponentInfo &info); PauseExperiment::PauseExperiment(const ParameterValueMap &parameters); bool PauseExperiment::execute(); void ResumeExperiment::describeComponent(ComponentInfo &info); ResumeExperiment::ResumeExperiment(const ParameterValueMap &parameters); bool ResumeExperiment::execute(); bool TakeCalibrationSampleNow::execute(); StartAverageCalibrationSample::StartAverageCalibrationSample(shared_ptr<Calibrator> _calibrator); bool StartAverageCalibrationSample::execute(); bool EndAverageAndTakeCalibrationSample::execute(); EndAverageAndIgnore::EndAverageAndIgnore(shared_ptr<Calibrator> _calibrator); bool EndAverageAndIgnore::execute(); CalibrateNow::CalibrateNow(shared_ptr<Calibrator> _calibrator); bool CalibrateNow::execute(); ClearCalibration::ClearCalibration(shared_ptr<Calibrator> _calibrator); bool ClearCalibration::execute(); StartAverager::StartAverager(shared_ptr<AveragerUser> _averager); bool StartAverager::execute(); StopAverager::StopAverager(shared_ptr<AveragerUser> _averager); bool StopAverager::execute(); ClearAverager::ClearAverager(shared_ptr<AveragerUser> _averager); bool ClearAverager::execute();

9ad393b94ca4c97b937538ececea4811cc44a46edbf55685e70aea0947288945

emoon

fs-uae

src/debug.cpp

debug_bgetpeek

void debug_bgetpeek (uaecptr addr, uae_u32 v) { uae_u32 vv = v; if (!memwatch_enabled) return; memwatch_func (addr, 1, 1, &vv, MW_MASK_CPU_D_R, 0); }

void deactivate_debugger (void); void activate_debugger_new(void); void activate_debugger_new_pc(uaecptr pc, int len); bool debug_enforcer(void); void debug_help (void); static void mw_help(void); static int debug_out (const TCHAR *format, ...); uae_u32 get_byte_debug (uaecptr addr); uae_u32 get_word_debug (uaecptr addr); uae_u32 get_long_debug (uaecptr addr); uae_u32 get_iword_debug (uaecptr addr); uae_u32 get_ilong_debug (uaecptr addr); static int safe_addr (uaecptr addr, int size); static bool iscancel (int counter); static bool isoperator(TCHAR **cp); static void ignore_ws (TCHAR **c); static TCHAR peekchar (TCHAR **c); static TCHAR readchar (TCHAR **c); static TCHAR next_char (TCHAR **c); static TCHAR peek_next_char (TCHAR **c); static int more_params (TCHAR **c); static int readregx (TCHAR **c, uae_u32 *valp); static bool readbinx (TCHAR **c, uae_u32 *valp); static bool readhexx (TCHAR **c, uae_u32 *valp); static bool readintx (TCHAR **c, uae_u32 *valp); static int checkvaltype2 (TCHAR **c, uae_u32 *val, TCHAR def); static int readsize (int val, TCHAR **c); static int checkvaltype (TCHAR **cp, uae_u32 *val, int *size, TCHAR def); static uae_u32 readnum (TCHAR **c, int *size, TCHAR def); static uae_u32 readint (TCHAR **c); static uae_u32 readhex (TCHAR **c); static uae_u32 readbin (TCHAR **c); static uae_u32 readint (TCHAR **c, int *size); static uae_u32 readhex (TCHAR **c, int *size); static int next_string (TCHAR **c, TCHAR *out, int max, int forceupper); static void converter (TCHAR **c); int notinrom (void); static uae_u32 lastaddr (void); static uaecptr nextaddr2 (uaecptr addr, int *next); static uaecptr nextaddr (uaecptr addr, uaecptr last, uaecptr *end); uaecptr dumpmem2 (uaecptr addr, TCHAR *out, int osize); static void dumpmem (uaecptr addr, uaecptr *nxmem, int lines); static void dump_custom_regs (int aga); static void dump_vectors (uaecptr addr); static void disassemble_wait (FILE *file, unsigned long insn); void record_dma_reset (void); void record_copper_reset (void); STATIC_INLINE uae_u32 ledcolor (uae_u32 c, uae_u32 *rc, uae_u32 *gc, uae_u32 *bc, uae_u32 *a); STATIC_INLINE void putpixel (uae_u8 *buf, int bpp, int x, xcolnr c8); static void set_dbg_color(int index, uae_u8 r, uae_u8 g, uae_u8 b); static void set_debug_colors(uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors); static void debug_draw_cycles (uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors); static void debug_draw_heatmap(uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors); void debug_draw(uae_u8 *buf, int bpp, int line, int width, int height, uae_u32 *xredcolors, uae_u32 *xgreencolors, uae_u32 *xbluescolors); static void heatmap_stats(TCHAR **c); static void free_heatmap(void); static void init_heatmap(void); static void memwatch_heatmap (uaecptr addr, int rwi, int size, uae_u32 accessmask); void record_dma_event (int evt, int hpos, int vpos); struct dma_rec *record_dma (uae_u16 reg, uae_u16 dat, uae_u32 addr, int hpos, int vpos, int type); static void decode_dma_record (int hpos, int vpos, int toggle, bool logfile); void log_dma_record (void); static void init_record_copper(void); void record_copper_blitwait (uaecptr addr, int hpos, int vpos); void record_copper (uaecptr addr, uae_u16 word1, uae_u16 word2, int hpos, int vpos); static struct cop_rec *find_copper_records (uaecptr addr); static void decode_copper_insn (FILE* file, uae_u16 mword1, uae_u16 mword2, unsigned long addr); static uaecptr decode_copperlist (FILE* file, uaecptr address, int nolines); static int copper_debugger (TCHAR **c); static void clearcheater(void); static int addcheater(uaecptr addr, int size); static void listcheater(int mode, int size); static void deepcheatsearch (TCHAR **c); static void cheatsearch (TCHAR **c); static void illg_free (void); static void illg_init (void); static void illg_debug_check (uaecptr addr, int rwi, int size, uae_u32 val); static void illg_debug_do (uaecptr addr, int rwi, int size, uae_u32 val); static int debug_mem_off (uaecptr *addrp); static void smc_free (void); static void smc_detect_init (TCHAR **c); static void smc_detector (uaecptr addr, int rwi, int size, uae_u32 *valp); uae_u8 *save_debug_memwatch (int *len, uae_u8 *dstptr); uae_u8 *restore_debug_memwatch (uae_u8 *src); void restore_debug_memwatch_finish (void); static int memwatch_func (uaecptr addr, int rwi, int size, uae_u32 *valp, uae_u32 accessmask, uae_u32 reg); static uae_u32 REGPARAM2 mmu_lget (uaecptr addr); static uae_u32 REGPARAM2 mmu_wget (uaecptr addr); static uae_u32 REGPARAM2 mmu_bget (uaecptr addr); static void REGPARAM2 mmu_lput (uaecptr addr, uae_u32 v); static void REGPARAM2 mmu_wput (uaecptr addr, uae_u32 v); static void REGPARAM2 mmu_bput (uaecptr addr, uae_u32 v); static uae_u32 REGPARAM2 debug_lget (uaecptr addr); static uae_u32 REGPARAM2 mmu_lgeti (uaecptr addr); static uae_u32 REGPARAM2 mmu_wgeti (uaecptr addr); static uae_u32 REGPARAM2 debug_wget (uaecptr addr); static uae_u32 REGPARAM2 debug_bget (uaecptr addr); static uae_u32 REGPARAM2 debug_lgeti (uaecptr addr); static uae_u32 REGPARAM2 debug_wgeti (uaecptr addr); static void REGPARAM2 debug_lput (uaecptr addr, uae_u32 v); static void REGPARAM2 debug_wput (uaecptr addr, uae_u32 v); static void REGPARAM2 debug_bput (uaecptr addr, uae_u32 v); static int REGPARAM2 debug_check (uaecptr addr, uae_u32 size); static uae_u8 *REGPARAM2 debug_xlate (uaecptr addr); uae_u16 debug_wputpeekdma_chipset (uaecptr addr, uae_u32 v, uae_u32 mask, int reg); uae_u16 debug_wputpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg); uae_u16 debug_wgetpeekdma_chipram (uaecptr addr, uae_u32 v, uae_u32 mask, int reg); static void debug_putlpeek (uaecptr addr, uae_u32 v); void debug_wputpeek (uaecptr addr, uae_u32 v); void debug_bputpeek (uaecptr addr, uae_u32 v); void debug_wgetpeek (uaecptr addr, uae_u32 v); void debug_lgetpeek (uaecptr addr, uae_u32 v); static void memwatch_reset (void); static void memwatch_remap (uaecptr addr); static void memwatch_setup (void); static int deinitialize_memwatch (void); static void initialize_memwatch (int mode); int debug_bankchange (int mode); addrbank *get_mem_bank_real(uaecptr addr); static const TCHAR *getsizechar (int size); void memwatch_dump2 (TCHAR *buf, int bufsize, int num); static void memwatch_dump (int num); static void memwatch (TCHAR **c); static void writeintomem (TCHAR **c); static uae_u8 *dump_xlate (uae_u32 addr); static void memory_map_dump_3(UaeMemoryMap *map, int log); void uae_memory_map(UaeMemoryMap *map); static void memory_map_dump_2 (int log); void memory_map_dump (void); STATIC_INLINE uaecptr BPTR2APTR (uaecptr addr); static TCHAR *BSTR2CSTR (uae_u8 *bstr); static void print_task_info (uaecptr node, bool nonactive); static void show_exec_tasks (void); uaecptr get_base (const uae_char *name, int offset); static TCHAR *getfrombstr(uaecptr pp); static void copyromdata(uae_u8 bustype, uaecptr rom, int offset, uae_u8 *out, int size); static void show_exec_lists (TCHAR *t); static void breakfunc(uae_u32 v); static int cycle_breakpoint(TCHAR **c); int instruction_breakpoint (TCHAR **c); static int process_breakpoint (TCHAR **c); static void savemem (TCHAR **cc); static void searchmem (TCHAR **cc); static int staterecorder (TCHAR **cc); void debugtest (enum debugtest_item di, const TCHAR *format, ...); static void debugtest_set (TCHAR **inptr); static void debug_sprite (TCHAR **inptr); int debug_write_memory_16 (uaecptr addr, uae_u16 v); int debug_write_memory_8 (uaecptr addr, uae_u8 v); int debug_peek_memory_16 (uaecptr addr); int debug_read_memory_16 (uaecptr addr); int debug_read_memory_8 (uaecptr addr); static void disk_debug (TCHAR **inptr); static void find_ea (TCHAR **inptr); static void m68k_modify (TCHAR **inptr); static int parse_string(TCHAR **inptr, TCHAR *str, int max_len); static void segtracker(TCHAR **inptr); static void ppc_disasm(uaecptr addr, uaecptr *nextpc, int cnt); static bool debug_line (TCHAR *input); static void debug_1 (void); static void addhistory (void); static void debug_continue(void); void debug (void); const TCHAR *debuginfo (int mode); void mmu_disasm (uaecptr pc, int lines); void mmu_do_hit (void); static void mmu_do_hit_pre (struct mmudata *md, uaecptr addr, int size, int rwi, uae_u32 v); static int mmu_hit (uaecptr addr, int size, int rwi, uae_u32 *v); static void mmu_free_node(struct mmunode *mn); static void mmu_free(void); static int getmmubank(struct mmudata *snptr, uaecptr p); int mmu_init(int mode, uaecptr parm, uaecptr parm2); void debug_parser (const TCHAR *cmd, TCHAR *out, uae_u32 outsize);

717aaeed7183c81c6b7091aa5be323c66641d5c0cc84dd292bd4019c02642385

web0316

WOW

dep/ACE_wrappers/ace/String_Base.cpp

ACE_String_Base<CHAR>::ACE_String_Base

ACE_String_Base<CHAR>::ACE_String_Base ( const CHAR *s, typename ACE_String_Base<CHAR>::size_type len, ACE_Allocator *the_allocator, bool release) : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()), len_ (0), buf_len_ (0), rep_ (0), release_ (false) { ACE_TRACE ("ACE_String_Base<CHAR>::ACE_String_Base"); this->set (s, len, release); }

ACE_String_Base<CHAR>::ACE_String_Base (ACE_Allocator *the_allocator); ACE_String_Base<CHAR>::ACE_String_Base (const ACE_String_Base<CHAR> &s); ACE_String_Base<CHAR>::~ACE_String_Base (void); u_long ACE_String_Base<CHAR>::hash (void); void ACE_String_Base<CHAR>::fast_resize (size_t len); void ACE_String_Base<CHAR>::clear (bool release); ACE_String_Base<CHAR> & ACE_String_Base<CHAR>::operator= (const CHAR *s); ACE_String_Base<CHAR> & ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s); void ACE_String_Base<CHAR>::set (const CHAR *s, bool release); void ACE_String_Base<CHAR>::fast_clear (void); CHAR * ACE_String_Base<CHAR>::rep (void); int ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s); bool ACE_String_Base<CHAR>::operator== (const ACE_String_Base<CHAR> &s); bool ACE_String_Base<CHAR>::operator== (const CHAR *s); void ACE_String_Base<CHAR>::swap (ACE_String_Base<CHAR> & str); ACE_String_Base<CHAR> operator+ (const ACE_String_Base<CHAR> &s, const ACE_String_Base<CHAR> &t); ACE_String_Base<CHAR> operator+ (const CHAR *s, const ACE_String_Base<CHAR> &t); ACE_String_Base<CHAR> operator+ (const ACE_String_Base<CHAR> &s, const CHAR *t);

1525af44056d8d5e084f3bc11ff50f72e00274182addada9bafb5f2b30192d8d

smogpill

core

src/pattern/thread/coTaskScheduler.cpp

coTaskScheduler::~coTaskScheduler

coTaskScheduler::~coTaskScheduler() { Stop(); for (auto* w : workers) delete w; }

coTaskScheduler::coTaskScheduler(coUint nbWorkers); void coTaskScheduler::Add(coTask& task); void coTaskScheduler::_ExecuteOneTask(const coTaskContext& context); void coTaskScheduler::OnStop(); coResult coTaskScheduler::OnStart();

191f9b3d051cff5ff8934eff61d56288361b92a64cf881132a8a0fdef6026e13

Fiware

data.Orion

src/lib/jsonParse/jsonUpdateContextRequest.cpp

metadataName

static std::string metadataName(const std::string& path, const std::string& value, ParseData* reqDataP) { LM_T(LmtParse, ("Got a metadata name: '%s'", value.c_str())); reqDataP->upcr.contextMetadataP->name = safeValue(value); return "OK"; }

static std::string contextElement(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string entityIdId(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string entityIdType(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string entityIdIsPattern(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string attribute(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string attributeName(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string attributeType(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string attributeValue(const std::string& path, const std::string& value, ParseData* parseDataP); static std::string metadata(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string metadataType(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string metadataValue(const std::string& path, const std::string& value, ParseData* reqDataP); static std::string updateAction(const std::string& path, const std::string& value, ParseData* reqDataP); void jsonUpcrInit(ParseData* reqDataP); void jsonUpcrRelease(ParseData* reqDataP); std::string jsonUpcrCheck(ParseData* reqData, ConnectionInfo* ciP);

10409453be714513638c53ba31d202adb84156d4efdd7b725ce374e79d03abcf

prpr-man

Cevious

Cevious/Vector2.cpp

Vector2::Vector2

Vector2::Vector2(const Vector2 &rhs) { x = rhs.x; y = rhs.y; }

Vector2::Vector2(void); Vector2::Vector2(double x,double y); bool Vector2::operator==(const Vector2 &rhs); bool Vector2::operator!=(const Vector2 &rhs); Vector2 Vector2::operator*(double rhs); Vector2& Vector2::operator*=(double rhs); Vector2 Vector2::operator/(double rhs); Vector2& Vector2::operator/=(double rhs); Vector2 Vector2::operator+(const Vector2 &rhs); Vector2& Vector2::operator+=(const Vector2 &rhs); Vector2 Vector2::operator-(const Vector2 &rhs); Vector2& Vector2::operator-=(const Vector2 &rhs); Vector2 Vector2::operator+(void); Vector2 Vector2::operator-(void); Vector2& Vector2::normalize(void); Vector2 Vector2::normalized(void); double Vector2::dot(const Vector2 &rhs); double Vector2::magnitude(void); double Vector2::angle(const Vector2 &rhs, bool degree); double Vector2::distance(const Vector2 &lhs, const Vector2 &rhs);

00c8f6468b1d47428bfe13e350b54acd2e1e052768c34732fa01cdc85828608f

tkelman

utf8rewind

source/tests/suite-utf8-seek-current-backwards.cpp

TEST

TEST(Utf8SeekCurrentBackwards, SixBytesMultiple) { const char* t = "\xFD\x87\x91\x81\xB2\xB1\xFC\xBF\xB2\xBA\xB0\xA2" "\xFC\x91\x81\x92\xA2\xA2"; EXPECT_SEEKEQ(t, 12, strlen(t), strlen(t), 0, -1, SEEK_CUR); EXPECT_SEEKEQ(t, 6, strlen(t), strlen(t), 0, -2, SEEK_CUR); EXPECT_SEEKEQ(t, 0, strlen(t), strlen(t), 0, -3, SEEK_CUR); }

TEST(Utf8SeekCurrentBackwards, OneByteSingle); TEST(Utf8SeekCurrentBackwards, OneByteSingleFirst); TEST(Utf8SeekCurrentBackwards, OneByteSingleLast); TEST(Utf8SeekCurrentBackwards, OneByteSinglePastStart); TEST(Utf8SeekCurrentBackwards, OneByteSingleInvalidContinuationByteFirst); TEST(Utf8SeekCurrentBackwards, OneByteSingleInvalidContinuationByteLast); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongThreeBytes); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongFourBytes); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongFiveBytes); TEST(Utf8SeekCurrentBackwards, OneByteSingleOverlongSixBytes); TEST(Utf8SeekCurrentBackwards, OneByteMultiple); TEST(Utf8SeekCurrentBackwards, OneByteMultipleContinuationBytes); TEST(Utf8SeekCurrentBackwards, OneByteMultipleOverlong); TEST(Utf8SeekCurrentBackwards, TwoBytesSingle); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleFirst); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleLast); TEST(Utf8SeekCurrentBackwards, TwoBytesSinglePastStart); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleInvalidContinuationFirstByteLower); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleInvalidContinuationFirstByteUpper); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleMissingOneByte); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongThreeBytes); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongFourBytes); TEST(Utf8SeekCurrentBackwards, TwoBytesSingleOverlongFiveBytes); TEST(Utf8SeekCurrentBackwards, TwoBytesMultiple); TEST(Utf8SeekCurrentBackwards, TwoBytesMultipleInvalid); TEST(Utf8SeekCurrentBackwards, TwoBytesMultipleOverlong); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingle); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleFirst); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleLast); TEST(Utf8SeekCurrentBackwards, ThreeBytesSinglePastStart); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationFirstByteLower); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationFirstByteUpper); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationSecondByteLower); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleInvalidContinuationSecondByteUpper); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleMissingOneByte); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleMissingTwoBytes); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongThreeBytes); TEST(Utf8SeekCurrentBackwards, ThreeBytesSingleOverlongFourBytes); TEST(Utf8SeekCurrentBackwards, ThreeBytesMultiple); TEST(Utf8SeekCurrentBackwards, ThreeBytesMultipleInvalid); TEST(Utf8SeekCurrentBackwards, ThreeBytesMultipleOverlong); TEST(Utf8SeekCurrentBackwards, FourBytesSingle); TEST(Utf8SeekCurrentBackwards, FourBytesSingleFirst); TEST(Utf8SeekCurrentBackwards, FourBytesSingleLast); TEST(Utf8SeekCurrentBackwards, FourBytesSinglePastStart); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationFirstByteLower); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationFirstByteUpper); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationSecondByteLower); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationSecondByteUpper); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationThirdByteLower); TEST(Utf8SeekCurrentBackwards, FourBytesSingleInvalidContinuationThirdByteUpper); TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingOneByte); TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingTwoBytes); TEST(Utf8SeekCurrentBackwards, FourBytesSingleMissingThreeBytes); TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, FourBytesSingleOverlongThreeBytes); TEST(Utf8SeekCurrentBackwards, FourBytesMultiple); TEST(Utf8SeekCurrentBackwards, FourBytesMultipleInvalid); TEST(Utf8SeekCurrentBackwards, FourBytesMultipleOverlong); TEST(Utf8SeekCurrentBackwards, FiveBytesSingle); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleFirst); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleLast); TEST(Utf8SeekCurrentBackwards, FiveBytesSinglePastStart); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFirstByteLower); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFirstByteUpper); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationSecondByteLower); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationSecondByteUpper); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationThirdByteLower); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationThirdByteUpper); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFourthByteLower); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleInvalidContinuationFourthByteUpper); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingOneByte); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingTwoBytes); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingThreeBytes); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleMissingFourBytes); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, FiveBytesSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, FiveBytesMultiple); TEST(Utf8SeekCurrentBackwards, FiveBytesMultipleInvalid); TEST(Utf8SeekCurrentBackwards, FiveBytesMultipleOverlong); TEST(Utf8SeekCurrentBackwards, SixBytesSingle); TEST(Utf8SeekCurrentBackwards, SixBytesSingleFirst); TEST(Utf8SeekCurrentBackwards, SixBytesSingleLast); TEST(Utf8SeekCurrentBackwards, SixBytesSinglePastStart); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFirstByteLower); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFirstByteUpper); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationSecondByteLower); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationSecondByteUpper); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationThirdByteLower); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationThirdByteUpper); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFourthByteLower); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFourthByteUpper); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFifthByteLower); TEST(Utf8SeekCurrentBackwards, SixBytesSingleInvalidContinuationFifthByteUpper); TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingOneByte); TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingTwoBytes); TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingThreeBytes); TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingFourBytes); TEST(Utf8SeekCurrentBackwards, SixBytesSingleMissingFiveBytes); TEST(Utf8SeekCurrentBackwards, SixBytesSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, SixBytesMultipleInvalid); TEST(Utf8SeekCurrentBackwards, SixBytesMultipleOverlong); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleFirst); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleLast); TEST(Utf8SeekCurrentBackwards, IllegalByteSinglePastStart); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongOneByte); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongTwoBytes); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongThreeBytes); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongFourBytes); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongFiveBytes); TEST(Utf8SeekCurrentBackwards, IllegalByteSingleOverlongSixBytes); TEST(Utf8SeekCurrentBackwards, IllegalByteMultiple); TEST(Utf8SeekCurrentBackwards, IllegalByteMultipleOverlong); TEST(Utf8SeekCurrentBackwards, TextPastStart); TEST(Utf8SeekCurrentBackwards, TextAtStart); TEST(Utf8SeekCurrentBackwards, TextFromMiddle); TEST(Utf8SeekCurrentBackwards, TextEndsInMiddle);

fcc5d540e0afdc21523de692297a85a5fce6ab51efca972e307b38ae17c6b4f2

Yashi100

rhodes3.3.2

platform/android/Rhodes/jni/src/rhodessystem.cpp

rho_nativethread_end

RHO_GLOBAL void rho_nativethread_end(void *) { jvm()->DetachCurrentThread(); }

RHO_GLOBAL void android_set_path(const rho::String& root, const rho::String& sqlite); rho::String const &rho_root_path(); const char* rho_native_rhopath(); rho::String rho_cur_path(); static bool set_posix_environment(JNIEnv *env, jclass clsRE); RHO_GLOBAL void android_setup(JNIEnv *env); RHO_GLOBAL void *rho_nativethread_start();

8ebd3527f906868da46015951afb8b1bdd69cdfb39d4d760626901d1e1769eb8

epiqc

ScaffCC

clang/lib/StaticAnalyzer/Checkers/DebugCheckers.cpp

ento::shouldRegisterDominatorsTreeDumper

bool ento::shouldRegisterDominatorsTreeDumper(const LangOptions &LO) { return true; }

void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerDominatorsTreeDumper(CheckerManager &mgr); void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerPostDominatorsTreeDumper(CheckerManager &mgr); bool ento::shouldRegisterPostDominatorsTreeDumper(const LangOptions &LO); void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerControlDependencyTreeDumper(CheckerManager &mgr); bool ento::shouldRegisterControlDependencyTreeDumper(const LangOptions &LO); void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerLiveVariablesDumper(CheckerManager &mgr); bool ento::shouldRegisterLiveVariablesDumper(const LangOptions &LO); void checkASTCodeBody(const Decl *D, AnalysisManager& Mgr, BugReporter &BR); void ento::registerLiveStatementsDumper(CheckerManager &mgr); bool ento::shouldRegisterLiveStatementsDumper(const LangOptions &LO); void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerCFGViewer(CheckerManager &mgr); bool ento::shouldRegisterCFGViewer(const LangOptions &LO); void checkASTCodeBody(const Decl *D, AnalysisManager& mgr, BugReporter &BR); void ento::registerCFGDumper(CheckerManager &mgr); bool ento::shouldRegisterCFGDumper(const LangOptions &LO); void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr, BugReporter &BR); void ento::registerCallGraphViewer(CheckerManager &mgr); bool ento::shouldRegisterCallGraphViewer(const LangOptions &LO); void checkASTDecl(const TranslationUnitDecl *TU, AnalysisManager& mgr, BugReporter &BR); void ento::registerCallGraphDumper(CheckerManager &mgr); bool ento::shouldRegisterCallGraphDumper(const LangOptions &LO); static int compareEntry(const Table::MapEntryTy *const *LHS, const Table::MapEntryTy *const *RHS); void ento::registerConfigDumper(CheckerManager &mgr); bool ento::shouldRegisterConfigDumper(const LangOptions &LO); void checkEndAnalysis(ExplodedGraph &G, BugReporter &B,ExprEngine &Eng); void ento::registerExplodedGraphViewer(CheckerManager &mgr); bool ento::shouldRegisterExplodedGraphViewer(const LangOptions &LO); void checkPreStmt(const Stmt *S, CheckerContext &C); void ento::registerReportStmts(CheckerManager &mgr); bool ento::shouldRegisterReportStmts(const LangOptions &LO);

643c477650a5ffc9364df67a7dc515f540bcfd3cf23cd3cdb09f4c475be3c75b

Jiwan

x64dbg

x64_dbg_dbg/_dbgfunctions.cpp

_getaddrfromline

static duint _getaddrfromline(const char* szSourceFile, int line) { LONG displacement = 0; IMAGEHLP_LINE64 lineData; memset(&lineData, 0, sizeof(lineData)); lineData.SizeOfStruct = sizeof(lineData); if(!SymGetLineFromName64(fdProcessInfo->hProcess, NULL, szSourceFile, line, &displacement, &lineData)) return 0; return (duint)lineData.Address; }

const DBGFUNCTIONS* dbgfunctionsget(); static bool _assembleatex(duint addr, const char* instruction, char* error, bool fillnop); static bool _sectionfromaddr(duint addr, char* section); static bool _patchget(duint addr); static bool _patchinrange(duint start, duint end); static bool _mempatch(duint va, const unsigned char* src, duint size); static void _patchrestorerange(duint start, duint end); static bool _patchrestore(duint addr); static void _getcallstack(DBGCALLSTACK* callstack); static bool _getjitauto(bool* jit_auto); static bool _getcmdline(char* cmd_line, size_t* cbsize); static bool _setcmdline(const char* cmd_line); static bool _getjit(char* jit, bool jit64); bool _getprocesslist(DBGPROCESSINFO** entries, int* count); static void _memupdatemap(); static bool _getsourcefromaddr(duint addr, char* szSourceFile, int* line); static bool _valfromstring(const char* string, duint* value); void dbgfunctionsinit();

2474b4299d6c79719c0078e7820e1a26f4c7cba6788bc40151d0ffa254b7cea7

Try

Tempest

Engine/thirdparty/openal-soft/alc/effects/equalizer.cpp

EqualizerState::deviceUpdate

void EqualizerState::deviceUpdate(const DeviceBase*, const Buffer&) { for(auto &e : mChans) { std::for_each(std::begin(e.filter), std::end(e.filter), std::mem_fn(&BiquadFilter::clear)); std::fill(std::begin(e.CurrentGains), std::end(e.CurrentGains), 0.0f); } }

void EqualizerState::process(const size_t samplesToDo, const al::span<const FloatBufferLine> samplesIn, const al::span<FloatBufferLine> samplesOut); EffectStateFactory *EqualizerStateFactory_getFactory();

2ef9389ba9eac4db6aeafbb813125f5a5f38ce9e7ac2f2ff00a15169fa94f922

harmattan

meegotouch-controlpanel

controlpanel/tests/doubles/dcpappletmanager-fake.cpp

bool DcpAppletManager::isMetadataPreloaded

bool DcpAppletManager::isMetadataPreloaded() { return true; }

FakeDcpAppletManager(DcpAppletManager *mng); ~FakeDcpAppletManager(); void createTestApplet(const QString& name); DcpAppletObject *applet(const QString &name); DcpAppletMetadata *metadata(const QString &name); DcpAppletMetadataList list(); DcpAppletManager::DcpAppletManager (); DcpAppletManager::~DcpAppletManager (); bool DcpAppletManager::isAppletLoaded (const QString&); QList<DcpAppletObject*> DcpAppletManager::loadedApplets (); bool DcpAppletManager::containsFile(const QString &name); bool DcpAppletManager::containsName(const QString &name); void DcpAppletManager::processSingleDesktopFile(); bool DcpAppletManager::mainPageAppletFound();

43037a5349c968bf33637aebe69b91c46ad0b3aafb9f535ae82b5bf8fcd64f41

Amara1231

blizzlikecore

src/game/ScriptMgr.cpp

ScriptMgr::GODialogStatus

uint32 ScriptMgr::GODialogStatus(Player* pPlayer, GameObject* pGO) { Script *tmpscript = m_scripts[pGO->GetGOInfo()->ScriptId]; if (!tmpscript || !tmpscript->pGODialogStatus) return 100; pPlayer->PlayerTalkClass->ClearMenus(); return tmpscript->pGODialogStatus(pPlayer, pGO); }

void ScriptMgr::LoadDatabase(); ScriptMgr::ScriptMgr(); ScriptMgr::~ScriptMgr(); void ScriptMgr::ScriptsInit(); void DoScriptText(int32 iTextEntry, WorldObject* pSource, Unit* pTarget); void Script::RegisterSelf(); void ScriptMgr::OnLogin(Player *pPlayer); void ScriptMgr::OnLogout(Player *pPlayer); void ScriptMgr::OnPVPKill(Player *killer, Player *killed); char const* ScriptMgr::ScriptsVersion(); bool ScriptMgr::GossipHello (Player * pPlayer, Creature* pCreature); bool ScriptMgr::GossipSelect(Player* pPlayer, Creature* pCreature, uint32 uiSender, uint32 uiAction); bool ScriptMgr::GossipSelectWithCode(Player* pPlayer, Creature* pCreature, uint32 uiSender, uint32 uiAction, const char* sCode); bool ScriptMgr::GOSelect(Player* pPlayer, GameObject* pGO, uint32 uiSender, uint32 uiAction); bool ScriptMgr::GOSelectWithCode(Player* pPlayer, GameObject* pGO, uint32 uiSender, uint32 uiAction, const char* sCode); bool ScriptMgr::QuestAccept(Player* pPlayer, Creature* pCreature, Quest const* pQuest); bool ScriptMgr::QuestSelect(Player* pPlayer, Creature* pCreature, Quest const* pQuest); bool ScriptMgr::QuestComplete(Player* pPlayer, Creature* pCreature, Quest const* pQuest); bool ScriptMgr::ChooseReward(Player* pPlayer, Creature* pCreature, Quest const* pQuest, uint32 opt); uint32 ScriptMgr::NPCDialogStatus(Player* pPlayer, Creature* pCreature); bool ScriptMgr::ItemHello(Player* pPlayer, Item* pItem, Quest const* pQuest); bool ScriptMgr::ItemQuestAccept(Player* pPlayer, Item* pItem, Quest const* pQuest); bool ScriptMgr::GOHello(Player* pPlayer, GameObject* pGO); bool ScriptMgr::GOQuestAccept(Player* pPlayer, GameObject* pGO, Quest const* pQuest); bool ScriptMgr::GOChooseReward(Player* pPlayer, GameObject* pGO, Quest const* pQuest, uint32 opt); bool ScriptMgr::AreaTrigger(Player* pPlayer, AreaTriggerEntry const* atEntry); CreatureAI* ScriptMgr::GetAI(Creature* pCreature); bool ScriptMgr::ItemUse(Player* pPlayer, Item* pItem, SpellCastTargets const& targets); bool ScriptMgr::EffectDummyCreature(Unit *caster, uint32 spellId, uint32 effIndex, Creature *crTarget); InstanceData* ScriptMgr::CreateInstanceData(Map *map);

cf8149daafc004c73ec4f502a49acb5229b281233b2b57ad75c4df2a32efd565

devxkh

FrankE

src/Tests/TestDispatcher/main.cpp

main

int main() { GrapicsManager gm; GameThread mGameThread(&gm); while (true) { std::chrono::milliseconds dura(5000); std::this_thread::sleep_for(dura); } }

QueueHandler(); void AddOnSomethingHandler(OnSomethingHandler Handler); void TriggerRenderEvents(void); void setPosition(int val); Entity::Entity(GrapicsManager* gmanager); void Entity::createEntity(int id); void Entity::setEntityPosition(int val); GrapicsManager::GrapicsManager(); void GrapicsManager::RenderLoop(); GameThread(GrapicsManager* gmanager); void GameLoop();

6acf3f9d2c2b788652dc475b7334e2991db75fda457c6ac289e4f0cacc7bdbb1

chiaming0914

awe-cpp-sdk

aws-cpp-sdk-inspector/source/InspectorClient.cpp

InspectorClient::StartDataCollectionAsyncHelper

oid InspectorClient::StartDataCollectionAsyncHelper(const StartDataCollectionRequest& request, const StartDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context) const { handler(this, request, StartDataCollection(request), context); }

nspectorClient::InspectorClient(const Client::ClientConfiguration& clientConfiguration); nspectorClient::InspectorClient(const AWSCredentials& credentials, const Client::ClientConfiguration& clientConfiguration); nspectorClient::InspectorClient(const std::shared_ptr<AWSCredentialsProvider>& credentialsProvider, const Client::ClientConfiguration& clientConfiguration); nspectorClient::~InspectorClient(); oid InspectorClient::init(const ClientConfiguration& config); ddAttributesToFindingsOutcome InspectorClient::AddAttributesToFindings(const AddAttributesToFindingsRequest& request); ddAttributesToFindingsOutcomeCallable InspectorClient::AddAttributesToFindingsCallable(const AddAttributesToFindingsRequest& request); oid InspectorClient::AddAttributesToFindingsAsync(const AddAttributesToFindingsRequest& request, const AddAttributesToFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::AddAttributesToFindingsAsyncHelper(const AddAttributesToFindingsRequest& request, const AddAttributesToFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); ttachAssessmentAndRulesPackageOutcome InspectorClient::AttachAssessmentAndRulesPackage(const AttachAssessmentAndRulesPackageRequest& request); ttachAssessmentAndRulesPackageOutcomeCallable InspectorClient::AttachAssessmentAndRulesPackageCallable(const AttachAssessmentAndRulesPackageRequest& request); oid InspectorClient::AttachAssessmentAndRulesPackageAsync(const AttachAssessmentAndRulesPackageRequest& request, const AttachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::AttachAssessmentAndRulesPackageAsyncHelper(const AttachAssessmentAndRulesPackageRequest& request, const AttachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); reateApplicationOutcome InspectorClient::CreateApplication(const CreateApplicationRequest& request); reateApplicationOutcomeCallable InspectorClient::CreateApplicationCallable(const CreateApplicationRequest& request); oid InspectorClient::CreateApplicationAsync(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::CreateApplicationAsyncHelper(const CreateApplicationRequest& request, const CreateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); reateAssessmentOutcome InspectorClient::CreateAssessment(const CreateAssessmentRequest& request); reateAssessmentOutcomeCallable InspectorClient::CreateAssessmentCallable(const CreateAssessmentRequest& request); oid InspectorClient::CreateAssessmentAsync(const CreateAssessmentRequest& request, const CreateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::CreateAssessmentAsyncHelper(const CreateAssessmentRequest& request, const CreateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); reateResourceGroupOutcome InspectorClient::CreateResourceGroup(const CreateResourceGroupRequest& request); reateResourceGroupOutcomeCallable InspectorClient::CreateResourceGroupCallable(const CreateResourceGroupRequest& request); oid InspectorClient::CreateResourceGroupAsync(const CreateResourceGroupRequest& request, const CreateResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::CreateResourceGroupAsyncHelper(const CreateResourceGroupRequest& request, const CreateResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); eleteApplicationOutcome InspectorClient::DeleteApplication(const DeleteApplicationRequest& request); eleteApplicationOutcomeCallable InspectorClient::DeleteApplicationCallable(const DeleteApplicationRequest& request); oid InspectorClient::DeleteApplicationAsync(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DeleteApplicationAsyncHelper(const DeleteApplicationRequest& request, const DeleteApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); eleteAssessmentOutcome InspectorClient::DeleteAssessment(const DeleteAssessmentRequest& request); eleteAssessmentOutcomeCallable InspectorClient::DeleteAssessmentCallable(const DeleteAssessmentRequest& request); oid InspectorClient::DeleteAssessmentAsync(const DeleteAssessmentRequest& request, const DeleteAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DeleteAssessmentAsyncHelper(const DeleteAssessmentRequest& request, const DeleteAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); eleteRunOutcome InspectorClient::DeleteRun(const DeleteRunRequest& request); eleteRunOutcomeCallable InspectorClient::DeleteRunCallable(const DeleteRunRequest& request); oid InspectorClient::DeleteRunAsync(const DeleteRunRequest& request, const DeleteRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DeleteRunAsyncHelper(const DeleteRunRequest& request, const DeleteRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeApplicationOutcome InspectorClient::DescribeApplication(const DescribeApplicationRequest& request); escribeApplicationOutcomeCallable InspectorClient::DescribeApplicationCallable(const DescribeApplicationRequest& request); oid InspectorClient::DescribeApplicationAsync(const DescribeApplicationRequest& request, const DescribeApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeApplicationAsyncHelper(const DescribeApplicationRequest& request, const DescribeApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeAssessmentOutcome InspectorClient::DescribeAssessment(const DescribeAssessmentRequest& request); escribeAssessmentOutcomeCallable InspectorClient::DescribeAssessmentCallable(const DescribeAssessmentRequest& request); oid InspectorClient::DescribeAssessmentAsync(const DescribeAssessmentRequest& request, const DescribeAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeAssessmentAsyncHelper(const DescribeAssessmentRequest& request, const DescribeAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeCrossAccountAccessRoleOutcome InspectorClient::DescribeCrossAccountAccessRole(); escribeCrossAccountAccessRoleOutcomeCallable InspectorClient::DescribeCrossAccountAccessRoleCallable(); oid InspectorClient::DescribeCrossAccountAccessRoleAsync(const DescribeCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeCrossAccountAccessRoleAsyncHelper(const DescribeCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeFindingOutcome InspectorClient::DescribeFinding(const DescribeFindingRequest& request); escribeFindingOutcomeCallable InspectorClient::DescribeFindingCallable(const DescribeFindingRequest& request); oid InspectorClient::DescribeFindingAsync(const DescribeFindingRequest& request, const DescribeFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeFindingAsyncHelper(const DescribeFindingRequest& request, const DescribeFindingResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeResourceGroupOutcome InspectorClient::DescribeResourceGroup(const DescribeResourceGroupRequest& request); escribeResourceGroupOutcomeCallable InspectorClient::DescribeResourceGroupCallable(const DescribeResourceGroupRequest& request); oid InspectorClient::DescribeResourceGroupAsync(const DescribeResourceGroupRequest& request, const DescribeResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeResourceGroupAsyncHelper(const DescribeResourceGroupRequest& request, const DescribeResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeRulesPackageOutcome InspectorClient::DescribeRulesPackage(const DescribeRulesPackageRequest& request); escribeRulesPackageOutcomeCallable InspectorClient::DescribeRulesPackageCallable(const DescribeRulesPackageRequest& request); oid InspectorClient::DescribeRulesPackageAsync(const DescribeRulesPackageRequest& request, const DescribeRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeRulesPackageAsyncHelper(const DescribeRulesPackageRequest& request, const DescribeRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); escribeRunOutcome InspectorClient::DescribeRun(const DescribeRunRequest& request); escribeRunOutcomeCallable InspectorClient::DescribeRunCallable(const DescribeRunRequest& request); oid InspectorClient::DescribeRunAsync(const DescribeRunRequest& request, const DescribeRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DescribeRunAsyncHelper(const DescribeRunRequest& request, const DescribeRunResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); etachAssessmentAndRulesPackageOutcome InspectorClient::DetachAssessmentAndRulesPackage(const DetachAssessmentAndRulesPackageRequest& request); etachAssessmentAndRulesPackageOutcomeCallable InspectorClient::DetachAssessmentAndRulesPackageCallable(const DetachAssessmentAndRulesPackageRequest& request); oid InspectorClient::DetachAssessmentAndRulesPackageAsync(const DetachAssessmentAndRulesPackageRequest& request, const DetachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::DetachAssessmentAndRulesPackageAsyncHelper(const DetachAssessmentAndRulesPackageRequest& request, const DetachAssessmentAndRulesPackageResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); etAssessmentTelemetryOutcome InspectorClient::GetAssessmentTelemetry(const GetAssessmentTelemetryRequest& request); etAssessmentTelemetryOutcomeCallable InspectorClient::GetAssessmentTelemetryCallable(const GetAssessmentTelemetryRequest& request); oid InspectorClient::GetAssessmentTelemetryAsync(const GetAssessmentTelemetryRequest& request, const GetAssessmentTelemetryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::GetAssessmentTelemetryAsyncHelper(const GetAssessmentTelemetryRequest& request, const GetAssessmentTelemetryResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istApplicationsOutcome InspectorClient::ListApplications(const ListApplicationsRequest& request); istApplicationsOutcomeCallable InspectorClient::ListApplicationsCallable(const ListApplicationsRequest& request); oid InspectorClient::ListApplicationsAsync(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListApplicationsAsyncHelper(const ListApplicationsRequest& request, const ListApplicationsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istAssessmentAgentsOutcome InspectorClient::ListAssessmentAgents(const ListAssessmentAgentsRequest& request); istAssessmentAgentsOutcomeCallable InspectorClient::ListAssessmentAgentsCallable(const ListAssessmentAgentsRequest& request); oid InspectorClient::ListAssessmentAgentsAsync(const ListAssessmentAgentsRequest& request, const ListAssessmentAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListAssessmentAgentsAsyncHelper(const ListAssessmentAgentsRequest& request, const ListAssessmentAgentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istAssessmentsOutcome InspectorClient::ListAssessments(const ListAssessmentsRequest& request); istAssessmentsOutcomeCallable InspectorClient::ListAssessmentsCallable(const ListAssessmentsRequest& request); oid InspectorClient::ListAssessmentsAsync(const ListAssessmentsRequest& request, const ListAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListAssessmentsAsyncHelper(const ListAssessmentsRequest& request, const ListAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istAttachedAssessmentsOutcome InspectorClient::ListAttachedAssessments(const ListAttachedAssessmentsRequest& request); istAttachedAssessmentsOutcomeCallable InspectorClient::ListAttachedAssessmentsCallable(const ListAttachedAssessmentsRequest& request); oid InspectorClient::ListAttachedAssessmentsAsync(const ListAttachedAssessmentsRequest& request, const ListAttachedAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListAttachedAssessmentsAsyncHelper(const ListAttachedAssessmentsRequest& request, const ListAttachedAssessmentsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istAttachedRulesPackagesOutcome InspectorClient::ListAttachedRulesPackages(const ListAttachedRulesPackagesRequest& request); istAttachedRulesPackagesOutcomeCallable InspectorClient::ListAttachedRulesPackagesCallable(const ListAttachedRulesPackagesRequest& request); oid InspectorClient::ListAttachedRulesPackagesAsync(const ListAttachedRulesPackagesRequest& request, const ListAttachedRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListAttachedRulesPackagesAsyncHelper(const ListAttachedRulesPackagesRequest& request, const ListAttachedRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istFindingsOutcome InspectorClient::ListFindings(const ListFindingsRequest& request); istFindingsOutcomeCallable InspectorClient::ListFindingsCallable(const ListFindingsRequest& request); oid InspectorClient::ListFindingsAsync(const ListFindingsRequest& request, const ListFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListFindingsAsyncHelper(const ListFindingsRequest& request, const ListFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istRulesPackagesOutcome InspectorClient::ListRulesPackages(const ListRulesPackagesRequest& request); istRulesPackagesOutcomeCallable InspectorClient::ListRulesPackagesCallable(const ListRulesPackagesRequest& request); oid InspectorClient::ListRulesPackagesAsync(const ListRulesPackagesRequest& request, const ListRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListRulesPackagesAsyncHelper(const ListRulesPackagesRequest& request, const ListRulesPackagesResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istRunsOutcome InspectorClient::ListRuns(const ListRunsRequest& request); istRunsOutcomeCallable InspectorClient::ListRunsCallable(const ListRunsRequest& request); oid InspectorClient::ListRunsAsync(const ListRunsRequest& request, const ListRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListRunsAsyncHelper(const ListRunsRequest& request, const ListRunsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); istTagsForResourceOutcome InspectorClient::ListTagsForResource(const ListTagsForResourceRequest& request); istTagsForResourceOutcomeCallable InspectorClient::ListTagsForResourceCallable(const ListTagsForResourceRequest& request); oid InspectorClient::ListTagsForResourceAsync(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::ListTagsForResourceAsyncHelper(const ListTagsForResourceRequest& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); ocalizeTextOutcome InspectorClient::LocalizeText(const LocalizeTextRequest& request); ocalizeTextOutcomeCallable InspectorClient::LocalizeTextCallable(const LocalizeTextRequest& request); oid InspectorClient::LocalizeTextAsync(const LocalizeTextRequest& request, const LocalizeTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::LocalizeTextAsyncHelper(const LocalizeTextRequest& request, const LocalizeTextResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); reviewAgentsForResourceGroupOutcome InspectorClient::PreviewAgentsForResourceGroup(const PreviewAgentsForResourceGroupRequest& request); reviewAgentsForResourceGroupOutcomeCallable InspectorClient::PreviewAgentsForResourceGroupCallable(const PreviewAgentsForResourceGroupRequest& request); oid InspectorClient::PreviewAgentsForResourceGroupAsync(const PreviewAgentsForResourceGroupRequest& request, const PreviewAgentsForResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::PreviewAgentsForResourceGroupAsyncHelper(const PreviewAgentsForResourceGroupRequest& request, const PreviewAgentsForResourceGroupResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); egisterCrossAccountAccessRoleOutcome InspectorClient::RegisterCrossAccountAccessRole(const RegisterCrossAccountAccessRoleRequest& request); egisterCrossAccountAccessRoleOutcomeCallable InspectorClient::RegisterCrossAccountAccessRoleCallable(const RegisterCrossAccountAccessRoleRequest& request); oid InspectorClient::RegisterCrossAccountAccessRoleAsync(const RegisterCrossAccountAccessRoleRequest& request, const RegisterCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::RegisterCrossAccountAccessRoleAsyncHelper(const RegisterCrossAccountAccessRoleRequest& request, const RegisterCrossAccountAccessRoleResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); emoveAttributesFromFindingsOutcome InspectorClient::RemoveAttributesFromFindings(const RemoveAttributesFromFindingsRequest& request); emoveAttributesFromFindingsOutcomeCallable InspectorClient::RemoveAttributesFromFindingsCallable(const RemoveAttributesFromFindingsRequest& request); oid InspectorClient::RemoveAttributesFromFindingsAsync(const RemoveAttributesFromFindingsRequest& request, const RemoveAttributesFromFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::RemoveAttributesFromFindingsAsyncHelper(const RemoveAttributesFromFindingsRequest& request, const RemoveAttributesFromFindingsResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); unAssessmentOutcome InspectorClient::RunAssessment(const RunAssessmentRequest& request); unAssessmentOutcomeCallable InspectorClient::RunAssessmentCallable(const RunAssessmentRequest& request); oid InspectorClient::RunAssessmentAsync(const RunAssessmentRequest& request, const RunAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::RunAssessmentAsyncHelper(const RunAssessmentRequest& request, const RunAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); etTagsForResourceOutcome InspectorClient::SetTagsForResource(const SetTagsForResourceRequest& request); etTagsForResourceOutcomeCallable InspectorClient::SetTagsForResourceCallable(const SetTagsForResourceRequest& request); oid InspectorClient::SetTagsForResourceAsync(const SetTagsForResourceRequest& request, const SetTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::SetTagsForResourceAsyncHelper(const SetTagsForResourceRequest& request, const SetTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); tartDataCollectionOutcome InspectorClient::StartDataCollection(const StartDataCollectionRequest& request); tartDataCollectionOutcomeCallable InspectorClient::StartDataCollectionCallable(const StartDataCollectionRequest& request); oid InspectorClient::StartDataCollectionAsync(const StartDataCollectionRequest& request, const StartDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); topDataCollectionOutcome InspectorClient::StopDataCollection(const StopDataCollectionRequest& request); topDataCollectionOutcomeCallable InspectorClient::StopDataCollectionCallable(const StopDataCollectionRequest& request); oid InspectorClient::StopDataCollectionAsync(const StopDataCollectionRequest& request, const StopDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::StopDataCollectionAsyncHelper(const StopDataCollectionRequest& request, const StopDataCollectionResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); pdateApplicationOutcome InspectorClient::UpdateApplication(const UpdateApplicationRequest& request); pdateApplicationOutcomeCallable InspectorClient::UpdateApplicationCallable(const UpdateApplicationRequest& request); oid InspectorClient::UpdateApplicationAsync(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::UpdateApplicationAsyncHelper(const UpdateApplicationRequest& request, const UpdateApplicationResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); pdateAssessmentOutcome InspectorClient::UpdateAssessment(const UpdateAssessmentRequest& request); pdateAssessmentOutcomeCallable InspectorClient::UpdateAssessmentCallable(const UpdateAssessmentRequest& request); oid InspectorClient::UpdateAssessmentAsync(const UpdateAssessmentRequest& request, const UpdateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context); oid InspectorClient::UpdateAssessmentAsyncHelper(const UpdateAssessmentRequest& request, const UpdateAssessmentResponseReceivedHandler& handler, const std::shared_ptr<const Aws::Client::AsyncCallerContext>& context);

62dd9524c2d039affdbdc70be7c75e1d365b979207f8561edec6dcefd5c8ffbc

rlugojr

incubator-trafodion

core/sql/sqlcomp/CmpSeabaseDDLcommon.cpp

grantSeabaseComponentPrivilege

static void grantSeabaseComponentPrivilege( const std::string & systemCatalog, StmtDDLGrantComponentPrivilege *pParseNode) { NAString privMgrMDLoc; CONCAT_CATSCH(privMgrMDLoc, systemCatalog.c_str(), SEABASE_PRIVMGR_SCHEMA); PrivMgrCommands componentPrivileges(std::string(privMgrMDLoc.data()),CmpCommon::diags()); if (!CmpCommon::context()->isAuthorizationEnabled()) { *CmpCommon::diags() << DgSqlCode(-CAT_AUTHORIZATION_NOT_ENABLED); return; } const std::string componentName = pParseNode->getComponentName().data(); const ConstStringList & privList = pParseNode->getComponentPrivilegeNameList(); const NAString & granteeName = pParseNode->getUserRoleName(); int32_t granteeID; if (ComUser::getAuthIDFromAuthName(granteeName.data(),granteeID) != 0) { *CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_DOES_NOT_EXIST_ERROR) << DgString0(granteeName.data()); return; } int32_t grantorID = ComUser::getCurrentUser(); std::string grantorName; ElemDDLGrantee *grantedBy = pParseNode->getGrantedBy(); if (grantedBy != NULL) { if (grantorID != ComUser::getRootUserID()) { PrivMgrComponentPrivileges componentPrivileges(std::string(privMgrMDLoc.data()),CmpCommon::diags()); if (!componentPrivileges.hasSQLPriv(grantorID, SQLOperation::MANAGE_COMPONENTS, true)) { *CmpCommon::diags() << DgSqlCode(-CAT_NOT_AUTHORIZED); return; } } ComString grantedByName = grantedBy->getAuthorizationIdentifier(); if (ComUser::getAuthIDFromAuthName(grantedByName.data(),grantorID) != 0) { *CmpCommon::diags() << DgSqlCode(-CAT_AUTHID_DOES_NOT_EXIST_ERROR) << DgString0(grantedByName.data()); return; } grantorName = grantedByName.data(); } else grantorName = ComUser::getCurrentUsername(); int32_t grantDepth = 0; if (pParseNode->isWithGrantOptionSpecified()) grantDepth = -1; vector<std::string> operationNamesList; for (size_t i = 0; i < privList.entries(); i++) { const ComString * operationName = privList[i]; operationNamesList.push_back(operationName->data()); } PrivStatus retcode = STATUS_GOOD; retcode = componentPrivileges.grantComponentPrivilege(componentName, operationNamesList, grantorID, grantorName, granteeID, granteeName.data(), grantDepth); if (retcode == STATUS_ERROR && CmpCommon::diags()->getNumber(DgSqlCode::ERROR_) == 0) SEABASEDDL_INTERNAL_ERROR("GRANT COMPONENT PRIVILEGE command"); }

CmpSeabaseDDL::CmpSeabaseDDL(NAHeap *heap, NABoolean syscatInit); short CmpSeabaseDDL::switchCompiler(Int32 cntxtType); short CmpSeabaseDDL::switchBackCompiler(); short CmpSeabaseDDL::createMDdescs(MDDescsInfo *&trafMDDescsInfo); NABoolean CmpSeabaseDDL::isHbase(const NAString &catName); ComBoolean CmpSeabaseDDL::isHbase(const ComObjectName &name); bool CmpSeabaseDDL::isHistogramTable(const NAString &name); bool CmpSeabaseDDL::isSampleTable(const NAString &name); NABoolean CmpSeabaseDDL::isLOBDependentNameMatch(const NAString &name); NABoolean CmpSeabaseDDL::isSeabase(const NAString &catName); ComBoolean CmpSeabaseDDL::isSeabase(const ComObjectName &name); std::vector<std::string> CmpSeabaseDDL::getHistogramTables(); ExpHbaseInterface* CmpSeabaseDDL::allocEHI(NADefaults * defs); void CmpSeabaseDDL::deallocEHI(ExpHbaseInterface* &ehi); ComBoolean CmpSeabaseDDL::isSeabaseMD(const ComObjectName &name); ComBoolean CmpSeabaseDDL::isSeabasePrivMgrMD(const ComObjectName &name); void CmpSeabaseDDL::restoreAllControlsAndFlags(); void CmpSeabaseDDL::processReturn(Lng32 retcode); short CmpSeabaseDDL::isMetadataInitialized(ExpHbaseInterface * ehi); NABoolean CmpSeabaseDDL::isAuthorizationEnabled(); void CmpSeabaseDDL::processSystemCatalog(NADefaults *defs); const char * CmpSeabaseDDL::getSystemCatalog(); NAString CmpSeabaseDDL::getSystemCatalogStatic(); NABoolean CmpSeabaseDDL::xnInProgress(ExeCliInterface *cliInterface); short CmpSeabaseDDL::beginXn(ExeCliInterface *cliInterface); short CmpSeabaseDDL::commitXn(ExeCliInterface *cliInterface); short CmpSeabaseDDL::rollbackXn(ExeCliInterface *cliInterface); short CmpSeabaseDDL::autoCommit(ExeCliInterface *cliInterface, NABoolean v); short CmpSeabaseDDL::ddlInvalidateNATables(); NABoolean CmpSeabaseDDL::enabledForSerialization(NAColumn * nac); NABoolean CmpSeabaseDDL::isEncodingNeededForSerialization(NAColumn * nac); static NABoolean isTrueFalseStr(const NAText& str); static NABoolean isHBaseCompressionOption(const NAText& str); static NABoolean isHBaseDurabilityOption(const NAText& str); static NABoolean isHBaseEncodingOption(const NAText& str); static NABoolean isHBaseBloomFilterOption(const NAText& str); static short isValidHbaseName(const char * str); short CmpSeabaseDDL::genTrafColFam(int index, NAString &trafColFamily); short CmpSeabaseDDL::extractTrafColFam(const NAString &trafColFam, int &index); short CmpSeabaseDDL::validateDivisionByExprForDDL(ItemExpr *divExpr); void CmpSeabaseDDL::initSeabaseMD(NABoolean ddlXns, NABoolean minimal); void CmpSeabaseDDL::createSeabaseMDviews(); void CmpSeabaseDDL::dropSeabaseMDviews(); void CmpSeabaseDDL::createSeabaseSchemaObjects(); short CmpSeabaseDDL::createSchemaObjects(ExeCliInterface *cliInterface); void CmpSeabaseDDL::createSeabaseSeqTable(); short CmpSeabaseDDL::createSeqTable(ExeCliInterface *cliInterface); void CmpSeabaseDDL::dropSeabaseMD(NABoolean ddlXns); void CmpSeabaseDDL::dropLOBHdfsFiles(); short CmpSeabaseDDL::dropMDTable(ExpHbaseInterface *ehi, const char * tab); void CmpSeabaseDDL::updateVersion(); void CmpSeabaseDDL::registerSeabaseUser(StmtDDLRegisterUser * authParseNode); void CmpSeabaseDDL::alterSeabaseUser(StmtDDLAlterUser * authParseNode); void CmpSeabaseDDL::unregisterSeabaseUser(StmtDDLRegisterUser * authParseNode); void CmpSeabaseDDL::giveSeabaseAll(StmtDDLGiveAll * giveAllParseNode); void CmpSeabaseDDL::giveSeabaseObject(StmtDDLGiveObject * giveObjectParseNode); void CmpSeabaseDDL::registerSeabaseComponent(StmtDDLRegisterComponent *pParseNode);

efb02cbd21be8406f931e81951c51284793f3291a795be8e7dd91f8f03c8f0ef

Kobzol

kaira

libs/cailie/process_shmem.cpp

ca::Process::init_collective_operations

void ca::Process::init_collective_operations(int process_count) { collective_transition_id = 0; pthread_barrier_init(&collective_barrier1, NULL, process_count); pthread_barrier_init(&collective_barrier2, NULL, process_count); }

void ca::Process::broadcast_packet(int tag, void *data, size_t size, int exclude); void ca::Process::add_packet(int from_process, int tag, void *data, size_t size); void Process::send(int target, Net *net, int edge_id, int tokens_count, Packer &packer, Thread *thread); int ca::Process::process_packets(Thread *thread); void ca::Process::setup_collective_operation(int transition_id, bool use_root, int root); void ca::Process::collective_scatter_root(int transition_id, const void *data, size_t size); void ca::Process::collective_scatter_nonroot(int transition_id, int root, void *out, size_t size); void ca::Process::collective_scatterv_root(int transition_id, const void *data, int *sizes, int *displs); void ca::Process::collective_scatterv_nonroot(int transition_id, int root, void *out, size_t size); void ca::Process::collective_gather_root(int transition_id, const void *data, size_t size, void *out); void ca::Process::collective_gather_nonroot(int transition_id, int root, const void *data, size_t size); void ca::Process::collective_bcast_root(int transition_id, const void *data, size_t size); void ca::Process::collective_bcast_nonroot(int transition_id, int root, void *out, size_t size); void ca::Process::collective_barrier(int transition_id); void ca::Process::collective_allgather(int transition_id, const void *data, size_t size, void *out);

12185fc97f248f54975a22ed26d92bae6f043bd272df9a660ac767fb54b7ca13

cbeck88

render_engine

src/kre/BlendOGL.cpp

get_equation_stack

std::stack<BlendEquation>& get_equation_stack() { static std::stack<BlendEquation> res; return res; }

GLenum convert_eqn(BlendEquationConstants eqn); GLenum convert_blend_mode(BlendModeConstants bm); std::stack<BlendMode>& get_blend_mode_stack(); std::stack<bool>& get_blend_state_stack(); BlendEquationImplOGL::BlendEquationImplOGL(); BlendEquationImplOGL::~BlendEquationImplOGL(); void BlendEquationImplOGL::apply(const BlendEquation& eqn); void BlendEquationImplOGL::clear(const BlendEquation& eqn); BlendEquationScopeOGL::BlendEquationScopeOGL(const ScopeableValue& sv); BlendEquationScopeOGL::~BlendEquationScopeOGL(); BlendModeScopeOGL::BlendModeScopeOGL(const ScopeableValue& sv); BlendModeScopeOGL::~BlendModeScopeOGL(); void set_blend_mode(const BlendMode& bm); void set_blend_equation(const BlendEquation& eqn);

38495c1451746987cf94491d7e11b7254748cd825420808542a0ae4f47a64f13

jasp-stats

jasp-desktop

Desktop/analysis/analysis.cpp

Analysis::createForm

oid Analysis::createForm(QQuickItem* parentItem) { AnalysisBase::createForm(parentItem); if (_analysisForm) { connect(this, &Analysis::rSourceChanged, _analysisForm, &AnalysisForm::rSourceChanged ); connect(this, &Analysis::refreshTableViewModels, _analysisForm, &AnalysisForm::refreshTableViewModels ); connect(this, &Analysis::titleChanged, _analysisForm, &AnalysisForm::titleChanged ); connect(this, &Analysis::needsRefreshChanged, _analysisForm, &AnalysisForm::needsRefreshChanged ); connect(this, &Analysis::boundValuesChanged, _analysisForm, &AnalysisForm::setRSyntaxText, Qt::QueuedConnection ); emit analysisInitialized(); } }

nalysis::Analysis(size_t id, Modules::AnalysisEntry * analysisEntry, std::string title, std::string moduleVersion, Json::Value *data); nalysis::Analysis(size_t id, Analysis * duplicateMe); oid Analysis::initAnalysis(); nalysis::~Analysis(); ool Analysis::checkAnalysisEntry(); oid Analysis::setTitle(const std::string& title); oid Analysis::abort(); oid Analysis::remove(); oid Analysis::setResults(const Json::Value & results, Status status, const Json::Value & progress); oid Analysis::exportResults(); oid Analysis::run(); oid Analysis::refresh(); oid Analysis::saveImage(const Json::Value &options); oid Analysis::imageSaved(const Json::Value & results); oid Analysis::editImage(const Json::Value &options); oid Analysis::imageEdited(const Json::Value & results); ool Analysis::updatePlotSize(const std::string & plotName, int width, int height, Json::Value & root); oid Analysis::rewriteImages(); oid Analysis::imagesRewritten(const Json::Value & results); nalysis::Status Analysis::parseStatus(std::string name); oid Analysis::destroyForm(); nalysis::Status Analysis::analysisResultsStatusToAnalysisStatus(analysisResultStatus result); td::string Analysis::statusToString(Status status); son::Value Analysis::asJSON(bool withRSource); oid Analysis::checkDefaultTitleFromJASPFile(const Json::Value & analysisData); oid Analysis::loadResultsUserdataAndRSourcesFromJASPFile(const Json::Value & analysisData, Status status); oid Analysis::setStatus(Analysis::Status status); oid Analysis::boundValueChangedHandler(); oid Analysis::requestComputedColumnCreationHandler(const std::string& columnName); oid Analysis::requestComputedColumnDestructionHandler(const std::string& columnName); erformType Analysis::desiredPerformTypeFromAnalysisStatus(); td::set<std::string> Analysis::usedVariables(); oid Analysis::runScriptRequestDone(const QString& result, const QString& controlName, bool hasError); son::Value Analysis::createAnalysisRequestJson(); oid Analysis::emitDuplicationSignals(); String Analysis::fullHelpPath(QString helpFileName); oid Analysis::duplicateMe(); oid Analysis::showDependenciesOnQMLForObject(QString uniqueName); ool Analysis::processResultsForDependenciesToBeShownMetaTraverser(const Json::Value & array); oid Analysis::processResultsForDependenciesToBeShown(); son::Value Analysis::editOptionsOfPlot(const std::string & uniqueName, bool emitError); ool Analysis::_editOptionsOfPlot(const Json::Value & results, const std::string & uniqueName, Json::Value & editOptions); oid Analysis::setEditOptionsOfPlot(const std::string & uniqueName, const Json::Value & editOptions); ool Analysis::_setEditOptionsOfPlot(Json::Value & results, const std::string & uniqueName, const Json::Value & editOptions); oid Analysis::setErrorInResults(const std::string & msg); ool Analysis::readyToCreateForm(); onst stringvec & Analysis::upgradeMsgsForOption(const std::string & name); son::Value Analysis::rSources(); oid Analysis::storeUserDataEtc(); oid Analysis::fitOldUserDataEtc(); oid Analysis::setUpgradeMsgs(const Modules::UpgradeMsgs &msgs); oid Analysis::setVersion(Version version, bool resetWasUpgraded); ool Analysis::needsRefresh(); ool Analysis::isWaitingForModule(); oid Analysis::setUserData(Json::Value userData); oid Analysis::setRSources(const Json::Value &rSources); oid Analysis::setDynamicModule(Modules::DynamicModule * module); oid Analysis::watchQmlForm(); oid Analysis::reloadForm(); oid Analysis::analysisQMLFileChanged(); oid Analysis::checkForRSources(); oid Analysis::clearRSources(); td::string Analysis::qmlFormPath(bool addFileProtocol, bool ignoreReadyForUse);

6e970bb7dfc3fe55bd50483ed9bddc8f1470bb9abc684924926ebe15f02dd82e

InfiniteInteractive

LimitlessSDK

sdk/Media/GPUImageSample.cpp

GpuImageSample::GpuImageSample

GpuImageSample::GpuImageSample(): m_flags(CL_MEM_READ_WRITE), m_width(0), m_height(0), m_channels(0), m_channelBits(0), m_texture(0) {}

GpuImageSample::GpuImageSample(unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits); GpuImageSample::GpuImageSample(unsigned char *buffer, unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits); GpuImageSample::~GpuImageSample(); unsigned char *GpuImageSample::buffer(size_t index); bool GpuImageSample::resize(unsigned int width, unsigned int height, unsigned int channels, unsigned int channelBits, bool inDrawThread); bool GpuImageSample::save(std::string fileName); bool GpuImageSample::write(IImageSample *imageSample, cl::Event &event, std::vector<cl::Event> *events); bool GpuImageSample::write(unsigned char *buffer, unsigned int width, unsigned int height, unsigned int channels, cl::Event &event, std::vector<cl::Event> *events); bool GpuImageSample::read(IImageSample *imageSample, cl::Event &event, std::vector<cl::Event> *events); bool GpuImageSample::read(unsigned char *buffer, unsigned int width, unsigned int height, cl::Event &event, std::vector<cl::Event> *events); bool GpuImageSample::copy(GpuImageSample *sample, cl::Event &event, std::vector<cl::Event> *waitEvents); bool GpuImageSample::acquireMultipleOpenCl(std::vector<GpuImageSample *> samples, cl::Event &event, std::vector<cl::Event> *waitEvents); bool GpuImageSample::releaseMultipleOpenCl(std::vector<GpuImageSample *> samples, cl::Event &event, std::vector<cl::Event> *waitEvents); bool GpuImageSample::acquireOpenCl(cl::Event &event, std::vector<cl::Event> *waitEvents); bool GpuImageSample::releaseOpenCl(cl::Event &event, std::vector<cl::Event> *waitEvents); bool GpuImageSample::acquireOpenGl(); bool GpuImageSample::releaseOpenGl();

04954b29dd2a4017532d1f531b26ca8ba3ecae1575e182f823fc29ba5c7e1d89

kocubinski

opentnl

tnl/platform.cpp

Platform::debugBreak

void Platform::debugBreak() { DebugBreak(); }

void Platform::outputDebugString(const char *string); void Platform::forceQuit(); U32 Platform::getRealMilliseconds(); void Platform::AlertOK(const char *windowTitle, const char *message); bool Platform::AlertOKCancel(const char *windowTitle, const char *message); bool Platform::AlertRetry(const char *windowTitle, const char *message); WinTimer(); S64 getCurrentTime(); F64 convertToMS(S64 delta); S64 Platform::getHighPrecisionTimerValue(); F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta); void Platform::sleep(U32 msCount); bool Platform::checkHeap(); void Platform::outputDebugString(const char *string); void Platform::debugBreak(); void Platform::forceQuit(); U32 Platform::getRealMilliseconds(); WinTimer(); S64 getCurrentTime(); F64 convertToMS(S64 delta); S64 Platform::getHighPrecisionTimerValue(); F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta); void Platform::sleep(U32 msCount); void Platform::AlertOK(const char *windowTitle, const char *message); bool Platform::AlertOKCancel(const char *windowTitle, const char *message); bool Platform::AlertRetry(const char *windowTitle, const char *message); void Platform::debugBreak(); void Platform::outputDebugString(const char *string); void Platform::forceQuit(); U32 Platform::getRealMilliseconds(); U32 x86UNIXGetTickCount(); UnixTimer(); S64 getCurrentTime(); F64 convertToMS(S64 delta); S64 Platform::getHighPrecisionTimerValue(); F64 Platform::getHighPrecisionMilliseconds(S64 timerDelta); void Platform::sleep(U32 msCount); void Platform::AlertOK(const char *windowTitle, const char *message); bool Platform::AlertOKCancel(const char *windowTitle, const char *message); bool Platform::AlertRetry(const char *windowTitle, const char *message); bool atob(const char *str); S32 dSprintf(char *buffer, U32 bufferSize, const char *format, ...); S32 dVsprintf(char *buffer, U32 bufferSize, const char *format, void *arglist); int stricmp(const char *str1, const char *str2); int strnicmp(const char *str1, const char *str2, unsigned int len);

00bb0cc9155359a00b62e676ef0a9718a2adfbe906e594bbc81a54aaf8481521

scbash

xbmc

xbmc/cores/VideoPlayer/DVDCodecs/Video/AddonVideoCodec.cpp

CAddonVideoCodec::GetPicture

CDVDVideoCodec::VCReturn CAddonVideoCodec::GetPicture(VideoPicture* pVideoPicture) { if (!m_struct.toAddon.get_picture) return CDVDVideoCodec::VC_ERROR; VIDEOCODEC_PICTURE picture; picture.flags = (m_codecFlags & DVD_CODEC_CTRL_DRAIN) ? VIDEOCODEC_PICTURE::FLAG_DRAIN : 0; switch (m_struct.toAddon.get_picture(&m_struct, &picture)) { case VIDEOCODEC_RETVAL::VC_NONE: return CDVDVideoCodec::VC_NONE; case VIDEOCODEC_RETVAL::VC_ERROR: return CDVDVideoCodec::VC_ERROR; case VIDEOCODEC_RETVAL::VC_BUFFER: return CDVDVideoCodec::VC_BUFFER; case VIDEOCODEC_RETVAL::VC_PICTURE: pVideoPicture->iWidth = picture.width; pVideoPicture->iHeight = picture.height; pVideoPicture->pts = static_cast<double>(picture.pts); pVideoPicture->dts = DVD_NOPTS_VALUE; pVideoPicture->iFlags = 0; pVideoPicture->chroma_position = 0; pVideoPicture->colorBits = 8; pVideoPicture->color_primaries = AVColorPrimaries::AVCOL_PRI_UNSPECIFIED; pVideoPicture->color_range = 0; pVideoPicture->color_space = AVCOL_SPC_UNSPECIFIED; pVideoPicture->color_transfer = 0; pVideoPicture->hasDisplayMetadata = false; pVideoPicture->hasLightMetadata = false; pVideoPicture->iDuration = 0; pVideoPicture->iFrameType = 0; pVideoPicture->iRepeatPicture = 0; pVideoPicture->pict_type = 0; pVideoPicture->qp_table = nullptr; pVideoPicture->qscale_type = 0; pVideoPicture->qstride = 0; pVideoPicture->stereoMode.clear(); if (m_codecFlags & DVD_CODEC_CTRL_DROP) pVideoPicture->iFlags |= DVP_FLAG_DROPPED; if (pVideoPicture->videoBuffer) pVideoPicture->videoBuffer->Release(); pVideoPicture->videoBuffer = static_cast<CVideoBuffer*>(picture.buffer); int strides[YuvImage::MAX_PLANES], planeOffsets[YuvImage::MAX_PLANES]; for (int i = 0; i<YuvImage::MAX_PLANES; ++i) strides[i] = picture.stride[i]; for (int i = 0; i<YuvImage::MAX_PLANES; ++i) planeOffsets[i] = picture.planeOffsets[i]; pVideoPicture->videoBuffer->SetDimensions(picture.width, picture.height, strides, planeOffsets); pVideoPicture->iDisplayWidth = pVideoPicture->iWidth; pVideoPicture->iDisplayHeight = pVideoPicture->iHeight; if (m_displayAspect > 0.0) { pVideoPicture->iDisplayWidth = ((int)lrint(pVideoPicture->iHeight * m_displayAspect)) & ~3; if (pVideoPicture->iDisplayWidth > pVideoPicture->iWidth) { pVideoPicture->iDisplayWidth = pVideoPicture->iWidth; pVideoPicture->iDisplayHeight = ((int)lrint(pVideoPicture->iWidth / m_displayAspect)) & ~3; } } CLog::Log(LOGDEBUG, LOGVIDEO, "CAddonVideoCodec: GetPicture::VC_PICTURE with pts {} {}x{} ({}x{}) {} {}:{} " "offset:{},{},{}, stride:{},{},{}", picture.pts, pVideoPicture->iWidth, pVideoPicture->iHeight, pVideoPicture->iDisplayWidth, pVideoPicture->iDisplayHeight, m_displayAspect, fmt::ptr(picture.decodedData), picture.decodedDataSize, picture.planeOffsets[0], picture.planeOffsets[1], picture.planeOffsets[2], picture.stride[0], picture.stride[1], picture.stride[2]); if (picture.width != m_width || picture.height != m_height) { m_width = picture.width; m_height = picture.height; m_processInfo.SetVideoDimensions(m_width, m_height); } return CDVDVideoCodec::VC_PICTURE; case VIDEOCODEC_RETVAL::VC_EOF: CLog::Log(LOGINFO, "CAddonVideoCodec: GetPicture: EOF"); return CDVDVideoCodec::VC_EOF; default: return CDVDVideoCodec::VC_ERROR; } }

CAddonVideoCodec::~CAddonVideoCodec(); bool CAddonVideoCodec::CopyToInitData(VIDEOCODEC_INITDATA &initData, CDVDStreamInfo &hints); bool CAddonVideoCodec::Open(CDVDStreamInfo &hints, CDVDCodecOptions &options); bool CAddonVideoCodec::Reconfigure(CDVDStreamInfo &hints); bool CAddonVideoCodec::AddData(const DemuxPacket &packet); const char* CAddonVideoCodec::GetName(); void CAddonVideoCodec::Reset(); bool CAddonVideoCodec::GetFrameBuffer(VIDEOCODEC_PICTURE &picture); void CAddonVideoCodec::ReleaseFrameBuffer(KODI_HANDLE videoBufferHandle); bool CAddonVideoCodec::get_frame_buffer(void* kodiInstance, VIDEOCODEC_PICTURE *picture); void CAddonVideoCodec::release_frame_buffer(void* kodiInstance, KODI_HANDLE videoBufferHandle);

46eb100d885fd5266da5787c359ca0071e5c1a2c6d61f96bdb21d8bf0dbd9994

joevandyk

osg

src/osgSim/MultiSwitch.cpp

MultiSwitch::getValue

bool MultiSwitch::getValue(unsigned int switchSet, unsigned int pos) const { if (switchSet>=_values.size()) return false; const ValueList& values = _values[switchSet]; if (pos>=values.size()) return false; return values[pos]; }

MultiSwitch::MultiSwitch(); MultiSwitch::MultiSwitch(const MultiSwitch& sw,const osg::CopyOp& copyop); void MultiSwitch::traverse(osg::NodeVisitor& nv); bool MultiSwitch::addChild( osg::Node *child); bool MultiSwitch::insertChild( unsigned int index, osg::Node *child); bool MultiSwitch::removeChild( osg::Node *child ); void MultiSwitch::setValue(unsigned int switchSet, unsigned int pos,bool value); void MultiSwitch::setChildValue(const osg::Node* child,unsigned int switchSet, bool value); bool MultiSwitch::getChildValue(const osg::Node* child, unsigned int switchSet); void MultiSwitch::expandToEncompassSwitchSet(unsigned int switchSet); bool MultiSwitch::setAllChildrenOff(unsigned int switchSet); bool MultiSwitch::setAllChildrenOn(unsigned int switchSet); bool MultiSwitch::setSingleChildOn(unsigned int switchSet, unsigned int pos); void MultiSwitch::setSwitchSetList(const SwitchSetList& switchSetList); void MultiSwitch::setValueList(unsigned int switchSet, const ValueList& values);

acfe75460fc6638dc05f39e0a0351bbd22e4e9d5481590e7f806035b6e1b1708

joaocc

ta3d-git

src/ta3d/src/backtrace.cpp

bug_reporter

void bug_reporter(const String &trace) { bool bSendReport = false; std::string report; report += TA3D_ENGINE_VERSION; #ifdef TA3D_CURRENT_REVISION report += " r"; report += TA3D_CURRENT_REVISION; #endif report += '\n'; if (!TA3D_CURRENT_MOD.empty()) { report += "MOD: "; report += TA3D_CURRENT_MOD.c_str(); report += '\n'; } report += "\nSystem info:\n"; #ifdef TA3D_PLATFORM_DARWIN report += "OS: darwin\n"; #elif defined TA3D_PLATFORM_LINUX report += "OS: linux\n"; #elif defined TA3D_PLATFORM_WINDOWS report += "OS: windows\n"; #else report += "OS: unknown\n"; #endif report += "OpenGL Informations :\n"; (report += "Vendor: ") += (const char*) glGetString(GL_VENDOR); (report += "\nRenderer: ") += (const char*) glGetString(GL_RENDERER); (report += "\nVersion: ") += (const char*) glGetString(GL_VERSION); report += "\nExtensions:\n"; const char *ext = (const char*) glGetString(GL_EXTENSIONS); for(; *ext ; ++ext) report += *ext == ' ' ? '\n' : *ext; report += '\n'; report += '\n'; report += "\nstacktrace:\n"; report += trace.c_str(); Gui::Window wnd("Bug report", 640, 240, Gui::Window::MOVEABLE); wnd.addChild(Gui::TabWidget_("tabs") / (Gui::Spacer_(false) | Gui::Button_("ok", " send report ") | Gui::Spacer_(false) | Gui::Button_("cancel", " don't send ") | Gui::Spacer_(false))); TABWIDGET(tabs)->addTab("info", Gui::Label_("info") / Gui::Spacer_(true) / Gui::Label_("size")); TABWIDGET(tabs)->addTab("report", Gui::ScrollArea_("scroll")); SCROLLAREA(scroll)->setCentralWidget(Gui::Label_("text", report)); BUTTON(ok)->addListener(Gui::Utils::actionSetBool(bSendReport)); BUTTON(ok)->addListener(Gui::Utils::actionCloseWindow()); BUTTON(cancel)->addListener(Gui::Utils::actionCloseWindow()); LABEL(info)->setCaption("An error has occured.\n" "A bug report has been prepared. You can review it in the 'report' tab.\n" "It contains information about your version of TA3D, OS, OpenGL renderer\n" "and a stack trace to help us find what's wrong.\n" "\n" "Do you want to send the bug report ?"); String buf; buf << "(report size = " << report.size() << " bytes)"; LABEL(size)->setCaption(buf.c_str()); wnd(); if (!bSendReport) return; TA3D::SocketTCP sock; sock.open("bugs.ta3d.org", 1905); if (!sock.isOpen()) { Gui::Utils::message("Socket error", "Error: could not connect to server."); return; } sock.send("BUG REPORT\n"); sock.send(report); sock.send("DISCONNECT"); SDL_Delay(2000); sock.close(); Gui::Utils::message("Success", "Bug report has been sent to server."); }

void backtrace_handler (int signum); virtual const char* sigpipe_what(); void sigpipe_handler (int /*signum*/); void init_signals (void); void clear_signals (void); void criticalMessage(const String &msg);

7078d6141e317e56d120d79d37a3a8d916b0e738fd5246de13e7460b2a4135a3

adpg211

bitcoin-master

src/test/TestBuffers.cpp

BOOST_AUTO_TEST_CASE

BOOST_AUTO_TEST_CASE(Parser) { MessageBuilder builder(NoHeader); builder.add(1, "bla"); builder.add(3, 100); builder.add(5, true); builder.add(100, false); std::vector<char> data; data.push_back(5); data.push_back(0); data.push_back(8); data.push_back(254); builder.add(6, data); builder.add(9, 15.5); uint256 origHash; origHash.SetHex("1298709234abd981729817291a8798172f871982a798195278312095a7982348"); builder.add(10, origHash); ConstBuffer buf = builder.buffer(); BOOST_CHECK(buf.size() == 59); MessageParser parser(buf); ParsedType type = parser.next(); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.tag() == 1); variant v = parser.data(); BOOST_CHECK(boost::get<std::string>(v) == std::string("bla")); type = parser.next(); BOOST_CHECK(parser.tag() == 3); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isLong() || parser.isInt()); BOOST_CHECK(parser.intData() == 100); type = parser.next(); BOOST_CHECK(parser.tag() == 5); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isBool()); BOOST_CHECK(parser.boolData() == true); type = parser.next(); BOOST_CHECK(parser.tag() == 100); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isBool()); BOOST_CHECK(parser.boolData() == false); type = parser.next(); BOOST_CHECK(parser.tag() == 6); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isByteArray()); v = parser.data(); std::vector<char> byteArray = boost::get<std::vector<char> >(v); BOOST_CHECK(byteArray == data); type = parser.next(); BOOST_CHECK(parser.tag() == 9); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isDouble()); v = parser.data(); double doubleData = boost::get<double>(v); BOOST_CHECK(doubleData == 15.5); BOOST_CHECK(parser.doubleData() == 15.5); type = parser.next(); BOOST_CHECK(parser.tag() == 10); BOOST_CHECK(type == FoundTag); BOOST_CHECK(parser.isByteArray()); uint256 hash(parser.unsignedBytesData()); BOOST_CHECK(origHash == hash); type = parser.next(); BOOST_CHECK(type == EndOfDocument); }

BOOST_AUTO_TEST_CASE(Basic); BOOST_AUTO_TEST_CASE(MultiBuffer); BOOST_AUTO_TEST_CASE(Builder); BOOST_AUTO_TEST_CASE(StringRefInParser); BOOST_AUTO_TEST_CASE(Clear); BOOST_AUTO_TEST_CASE(CMFBasic); BOOST_AUTO_TEST_CASE(CMFBasic2); BOOST_AUTO_TEST_CASE(CMFTypes);

fff3760e07465a9a88f4bf9edd7a61434c654c02cc1be6a27f31ba67c7e37971

lenovor

BBRL

src/DDS/src/Agent/VDBEEGreedyAgent.cpp

VDBEEGreedyAgent::freeData

void VDBEEGreedyAgent::freeData() { if (cModel) { delete cModel; cModel = 0; } Q.clear(); #ifndef NDEBUG checkIntegrity(); #endif }

VDBEEGreedyAgent::VDBEEGreedyAgent(std::istream& is); VDBEEGreedyAgent::~VDBEEGreedyAgent(); int VDBEEGreedyAgent::getAction(int xt); void VDBEEGreedyAgent::learnOnline(int x, int u, int y, double r); void VDBEEGreedyAgent::reset(); void VDBEEGreedyAgent::serialize(ostream& os); void VDBEEGreedyAgent::deserialize(istream& is); void VDBEEGreedyAgent::learnOffline_aux(const MDPDistribution* mdpDistrib); void VDBEEGreedyAgent::checkIntegrity();

0240e06ce76acb5093628524ae0e335e4b3352ba73f5c22a57bfd30488ebe44c

gsi-upm

SmartSim

smartbody/src/SmartBody/sb/SBVHMsgManager.cpp

SBVHMsgManager::getPort

const std::string& SBVHMsgManager::getPort() { return _port; }

VHMsgLogger(); virtual ~VHMsgLogger(); virtual void OnMessage( const std::string & message ); SBVHMsgManager::SBVHMsgManager(); SBVHMsgManager::~SBVHMsgManager(); void SBVHMsgManager::setEnable(bool val); bool SBVHMsgManager::isEnable(); bool SBVHMsgManager::isConnected(); bool SBVHMsgManager::connect(); void SBVHMsgManager::disconnect(); int SBVHMsgManager::send2( const char *op, const char* message ); int SBVHMsgManager::send( const char* message ); int SBVHMsgManager::poll(); void SBVHMsgManager::setPort(const std::string& port); void SBVHMsgManager::setServer(const std::string& server); const std::string& SBVHMsgManager::getServer(); void SBVHMsgManager::setScope(const std::string& scope); const std::string& SBVHMsgManager::getScope(); void SBVHMsgManager::vhmsgCallback( const char *op, const char *args, void * user_data ); void SBVHMsgManager::setEnableLogging(bool val); bool SBVHMsgManager::isEnableLogging(); SBAPI int SBVHMsgManager::sendMessage( const std::string& message ); SBAPI int SBVHMsgManager::sendOpMessage( const std::string& op, const std::string& message );

e19fcb2e6c4a9304d45ad5f5c2f603d9df45d7c2857e653bf0f34768b255e29f

brianbbsu

program

code archive/codechef/TREEWALK.cpp

main

int main() { IOS(); ll n,rt,k; cin>>n; REP(i,n-1) { ll a,b; cin>>a>>b; v[a].pb(b); v[b].pb(a); } cin>>rt>>k; if(k <= 3000) { ll dp[MAXn][MAXn]; FILL(dp,0); dp[rt][0] = 1; REP1(i,k)REP1(j,n) { for(ll t:v[j])dp[j][i] += dp[t][i-1]; dp[j][i] %= MOD; } REP1(i,n)cout<<dp[i][k]<<" "; cout<<endl; } else { ll dp[2][MAXn],mat[2][MAXn][MAXn]; ll dpfg = 0,matfg = 0; FILL(dp,0); FILL(mat,0); dp[0][rt] = 1; REP1(i,n)for(ll t:v[i])mat[0][i][t] = 1; while(k) { if(k & 1) { dpfg = !dpfg; FILL(dp[dpfg],0); REP1(i,n)REP1(j,n)dp[dpfg][i] += dp[!dpfg][j] * mat[matfg][j][i] % MOD; REP1(i,n)dp[dpfg][i] %= MOD; } matfg = !matfg; FILL(mat[matfg],0); REP1(i,n)REP1(j,n)REP1(t,n)mat[matfg][i][j] += mat[!matfg][i][t] * mat[!matfg][t][j] % MOD; REP1(i,n)REP1(j,n)mat[matfg][i][j] %= MOD; k /= 2; } REP1(i,n)cout<<dp[dpfg][i]<<" "; } }

ostream& _OUTC(ostream &_s,It _ita,It _itb);

479c7169bfbdaa9451892f1e674be790cae092cac7e85524183ceb1c5b6a34c9

gentooza

QueTalk

app/PrefGeneral.cpp

PrefGeneral::isRosterPrefChanged

l PrefGeneral::isRosterPrefChanged() const { return m_hideOfflineChange || m_showResourcesChange || m_showSingleResourceChange; } bo

fGeneral::PrefGeneral(QWidget *parent); fGeneral::~PrefGeneral(); on PrefGeneral::sectionIcon(); d PrefGeneral::changeEvent(QEvent *e); ring PrefGeneral::sectionName(); d PrefGeneral::readData(Preferences *pref); d PrefGeneral::writeData(Preferences *pref); l PrefGeneral::isLanguageChanged(); l PrefGeneral::isRosterIconSizeChanged(); d PrefGeneral::iconSizeChanged();

94c943a51edc1e36e8560693790d2bccf0069533631b84b09560d72e160b5094

freaktechnik

nightingale-hacking

components/devices/base/src/sbDeviceCapabilities.cpp

sbPlaylistFormatType::~sbPlaylistFormatType

sbPlaylistFormatType::~sbPlaylistFormatType() { }

sbDeviceCapabilities::sbDeviceCapabilities(); sbDeviceCapabilities::~sbDeviceCapabilities(); sbImageSize::~sbImageSize(); sbDevCapRange::~sbDevCapRange(); sbDevCapFraction::~sbDevCapFraction(); sbFormatTypeConstraint::~sbFormatTypeConstraint(); sbImageFormatType::~sbImageFormatType(); sbAudioFormatType::~sbAudioFormatType(); sbDevCapVideoStream::sbDevCapVideoStream(); sbDevCapVideoStream::~sbDevCapVideoStream(); NS_IMETHODIMP sbDevCapVideoStream::GetType(nsACString & aType); NS_IMETHODIMP sbDevCapVideoStream::GetSupportedExplicitSizes(nsIArray * *aSupportedExplicitSizes); NS_IMETHODIMP sbDevCapVideoStream::GetSupportedWidths(sbIDevCapRange * *aSupportedWidths); NS_IMETHODIMP sbDevCapVideoStream::GetSupportedHeights(sbIDevCapRange * *aSupportedHeights); NS_IMETHODIMP sbDevCapVideoStream::GetSupportedBitRates(sbIDevCapRange * *aSupportedBitRates); sbDevCapAudioStream::sbDevCapAudioStream(); sbDevCapAudioStream::~sbDevCapAudioStream(); NS_IMETHODIMP sbDevCapAudioStream::GetType(nsACString & aType); sbVideoFormatType::sbVideoFormatType(); sbVideoFormatType::~sbVideoFormatType(); sbPlaylistFormatType::sbPlaylistFormatType();

a063366556536104ba3f3501524024edf35170268569aec3d229090bb0c89240

revelator

Revelation

Doom3/neo/framework/Common.cpp

idCommonLocal::DPrintf

void idCommonLocal::DPrintf( const char *fmt, ... ) { va_list argptr; char msg[MAX_PRINT_MSG_SIZE]; if( !cvarSystem->IsInitialized() || !com_developer.GetBool() ) { return; } va_start( argptr, fmt ); idStr::vsnPrintf( msg, sizeof( msg ), fmt, argptr ); va_end( argptr ); msg[sizeof( msg ) - 1] = '\0'; bool temp = com_refreshOnPrint; com_refreshOnPrint = false; Printf( S_COLOR_RED"%s", msg ); com_refreshOnPrint = temp; }

version_s( void ); idCommonLocal::idCommonLocal( void ); void idCommonLocal::BeginRedirect( char *buffer, int buffersize, void ( *flush ); void idCommonLocal::EndRedirect( void ); BOOL CALLBACK EnumWindowsProc( HWND hwnd, LPARAM lParam ); bool FindEditor( void ); void idCommonLocal::CloseLogFile( void ); void idCommonLocal::SetRefreshOnPrint( bool set ); void idCommonLocal::VPrintf( const char *fmt, va_list args ); void idCommonLocal::Printf( const char *fmt, ... ); void idCommonLocal::DWarning( const char *fmt, ... ); void idCommonLocal::Warning( const char *fmt, ... ); void idCommonLocal::PrintWarnings( void ); void idCommonLocal::ClearWarnings( const char *reason ); void idCommonLocal::DumpWarnings( void ); void idCommonLocal::Error( const char *fmt, ... ); void idCommonLocal::FatalError( const char *fmt, ... ); void idCommonLocal::Quit( void ); void idCommonLocal::ParseCommandLine( int argc, const char **argv ); void idCommonLocal::ClearCommandLine( void ); bool idCommonLocal::SafeMode( void ); void idCommonLocal::CheckToolMode( void ); void idCommonLocal::StartupVariable( const char *match, bool once ); bool idCommonLocal::AddStartupCommands( void ); void idCommonLocal::InitTool( const toolFlag_t tool, const idDict *dict ); void idCommonLocal::ActivateTool( bool active ); void idCommonLocal::WriteFlaggedCVarsToFile( const char *filename, int flags, const char *setCmd ); void idCommonLocal::WriteConfigToFile( const char *filename ); void idCommonLocal::WriteConfiguration( void ); const char *idCommonLocal::KeysFromBinding( const char *bind ); const char *idCommonLocal::BindingFromKey( const char *key ); int idCommonLocal::ButtonState( int key ); int idCommonLocal::KeyState( int key ); static void Com_Editor_f( const idCmdArgs &args ); static void Com_EditGUIs_f( const idCmdArgs &args ); static void Com_MaterialEditor_f( const idCmdArgs &args ); static void PrintMemInfo_f( const idCmdArgs &args ); static void Com_EditLights_f( const idCmdArgs &args ); static void Com_EditSounds_f( const idCmdArgs &args ); static void Com_EditDecls_f( const idCmdArgs &args ); static void Com_EditAFs_f( const idCmdArgs &args ); static void Com_EditParticles_f( const idCmdArgs &args ); static void Com_EditScripts_f( const idCmdArgs &args ); static void Com_EditPDAs_f( const idCmdArgs &args ); static void Com_Error_f( const idCmdArgs &args ); static void Com_Freeze_f( const idCmdArgs &args ); static void Com_Crash_f( const idCmdArgs &args ); static void Com_Quit_f( const idCmdArgs &args ); void Com_WriteConfig_f( const idCmdArgs &args ); void Com_SetMachineSpec_f( const idCmdArgs &args ); void Com_ExecMachineSpec_f( const idCmdArgs &args ); void Com_ReloadEngine_f( const idCmdArgs &args ); const idLangDict *idCommonLocal::GetLanguageDict( void ); void idCommonLocal::FilterLangList( idStrList *list, idStr lang ); void idCommonLocal::InitLanguageDict( void ); void idCommonLocal::LocalizeSpecificMapData( const char *fileName, idLangDict &langDict, const idLangDict &replaceArgs ); void idCommonLocal::LocalizeMapData( const char *fileName, idLangDict &langDict ); void idCommonLocal::LocalizeGui( const char *fileName, idLangDict &langDict ); void Com_ReloadLanguage_f( const idCmdArgs &args ); void LoadMapLocalizeData( ListHash &listHash ); void LoadGuiParmExcludeList( idStrList &list ); bool TestMapVal( idStr &str ); bool TestGuiParm( const char *parm, const char *value, idStrList &excludeList ); void GetFileList( const char *dir, const char *ext, idStrList &list ); int LocalizeMap( const char *mapName, idLangDict &langDict, ListHash &listHash, idStrList &excludeList, bool writeFile ); void Com_LocalizeMaps_f( const idCmdArgs &args ); void Com_LocalizeGuis_f( const idCmdArgs &args ); void Com_LocalizeGuiParmsTest_f( const idCmdArgs &args ); void Com_LocalizeMapsTest_f( const idCmdArgs &args ); void Com_StartBuild_f( const idCmdArgs &args ); void Com_FinishBuild_f( const idCmdArgs &args ); void Com_Help_f( const idCmdArgs &args ); void idCommonLocal::InitCommands( void ); void idCommonLocal::InitRenderSystem( void ); void idCommonLocal::PrintLoadingMessage( const char *msg ); void idCommonLocal::InitSIMD( void ); void idCommonLocal::Frame( void ); void idCommonLocal::GUIFrame( bool execCmd, bool network ); void idCommonLocal::SingleAsyncTic( void ); void idCommonLocal::Async( void ); void idCommonLocal::LoadGameDLL( void ); void idCommonLocal::UnloadGameDLL( void ); bool idCommonLocal::IsInitialized( void ); void idCommonLocal::SetMachineSpec( void ); void idCommonLocal::Init( int argc, const char **argv, const char *cmdline ); void idCommonLocal::Shutdown( void ); void idCommonLocal::InitGame( void ); void idCommonLocal::ShutdownGame( bool reloading );

1005e57a23c0f0726087cf76e27ac2e6a1d447e289088db491ee23e3df55098c

iPodLinux-Community

iScummVM

engines/agi/text.cpp

TextMan::blit_textbox

void TextMan::blit_textbox(const char *p, int y, int x, int len) { int xoff, yoff, lin, h, w; char *msg, *m; debugC(3, kDebugLevelText, "x=%d, y=%d, len=%d", x, y, len); if (game.window.active) close_window(); if (x == 0 && y == 0 && len == 0) x = y = -1; if (len <= 0 || len >= 40) len = 32; xoff = x * CHAR_COLS; yoff = y * CHAR_LINES; len--; m = msg = word_wrap_string(agi_sprintf(p), &len); for (lin = 1; *m; m++) { if (*m == '\n' || *m == '\r') lin++; } if (lin * CHAR_LINES > GFX_HEIGHT) lin = (GFX_HEIGHT / CHAR_LINES); w = (len + 2) * CHAR_COLS; h = (lin + 2) * CHAR_LINES; if (xoff < 0) xoff = (GFX_WIDTH - w - CHAR_COLS) / 2; else xoff -= CHAR_COLS; if (yoff < 0) yoff = (GFX_HEIGHT - 3 * CHAR_LINES - h) / 2; draw_window(xoff, yoff, xoff + w - 1, yoff + h - 1); print_text2(2, msg, 0, CHAR_COLS + xoff, CHAR_LINES + yoff, len + 1, MSG_BOX_TEXT, MSG_BOX_COLOUR); free(msg); do_update(); }

void TextMan::erase_textbox(); void TextMan::print_text(const char *msg, int f, int x, int y, int len, int fg, int bg); void TextMan::print_text_console(const char *msg, int x, int y, int len, int fg, int bg); char *TextMan::word_wrap_string(char *str, int *len); void TextMan::close_window(); int TextMan::message_box(const char *s); int TextMan::selection_box(const char *m, const char **b); int TextMan::print(const char *p, int lin, int col, int len); void TextMan::print_status(const char *message, ...); char *TextMan::safe_strcat(char *s, const char *t); char *TextMan::agi_sprintf(const char *s); void TextMan::write_status(); void TextMan::write_prompt(); void TextMan::clear_lines(int l1, int l2, int c); void TextMan::flush_lines(int l1, int l2); void TextMan::draw_window(int x1, int y1, int x2, int y2);

e761b4b8d4b43ad3aac06befef8de8c096627ed8e113ce515920f71c254305c0

acristoffers

CMake-AVR

Arduino/Arduino/SD/Sd2Card.cpp

spiRec

tatic uint8_t spiRec(void) { spiSend(0XFF); return SPDR; }

tatic void spiSend(uint8_t b); int8_t spiRec(void); oid spiSend(uint8_t data); int8_t Sd2Card::cardCommand(uint8_t cmd, uint32_t arg); int32_t Sd2Card::cardSize(void); oid Sd2Card::chipSelectHigh(void); oid Sd2Card::chipSelectLow(void); int8_t Sd2Card::erase(uint32_t firstBlock, uint32_t lastBlock); int8_t Sd2Card::eraseSingleBlockEnable(void); int8_t Sd2Card::init(uint8_t sckRateID, uint8_t chipSelectPin); oid Sd2Card::partialBlockRead(uint8_t value); int8_t Sd2Card::readBlock(uint32_t block, uint8_t *dst); int8_t Sd2Card::readData(uint32_t block, uint16_t offset, uint16_t count, uint8_t *dst); oid Sd2Card::readEnd(void); int8_t Sd2Card::readRegister(uint8_t cmd, void *buf); int8_t Sd2Card::setSckRate(uint8_t sckRateID); int8_t Sd2Card::waitNotBusy(uint16_t timeoutMillis); int8_t Sd2Card::waitStartBlock(void); int8_t Sd2Card::writeBlock(uint32_t blockNumber, const uint8_t *src); int8_t Sd2Card::writeData(const uint8_t *src); int8_t Sd2Card::writeData(uint8_t token, const uint8_t *src); int8_t Sd2Card::writeStart(uint32_t blockNumber, uint32_t eraseCount); int8_t Sd2Card::writeStop(void);

b65ab1e3dd927b6ed3056a5a4e14cd54ce90e60821fd72db60ab9a5563a7aeef

zxymd5

DirectXChess

Chess/ClientNetwork.cpp

CClientNetwork::RecvMsg

int CClientNetwork::RecvMsg( char szMsg[] ) { int nSize = CSockWrap::Recv(m_nSockFd, szMsg, MAX_MSG_SIZE, 0); if (nSize <= 0) { StopClient(); } return nSize; }

CClientNetwork::CClientNetwork(void); CClientNetwork::~CClientNetwork(void); void CClientNetwork::InitClient(); void CClientNetwork::ConnToServer( const char *pIpAddr, int nPort ); int CClientNetwork::SendMsg( char szMsg[], int nSize ); void CClientNetwork::StopClient();

51f6043ab0d343ae2f52fba8ee0c4277c10771a38e2a5c591ed5800d5e8b0c94

alexBraidwood

vmime

src/vmime/net/imap/IMAPCommand.cpp

IMAPCommand::SELECT

shared_ptr <IMAPCommand> IMAPCommand::SELECT (const bool readOnly, const string& mailboxName, const std::vector <string>& params) { std::ostringstream cmd; cmd.imbue(std::locale::classic()); if (readOnly) cmd << "EXAMINE "; else cmd << "SELECT "; cmd << IMAPUtils::quoteString(mailboxName); if (!params.empty()) { cmd << " ("; for (size_t i = 0, n = params.size() ; i < n ; ++i) { if (i != 0) cmd << " "; cmd << params[i]; } cmd << ")"; } return createCommand(cmd.str()); }

IMAPCommand::IMAPCommand(const string& text, const string& traceText); shared_ptr <IMAPCommand> IMAPCommand::LOGIN(const string& username, const string& password); shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName); shared_ptr <IMAPCommand> IMAPCommand::AUTHENTICATE(const string& mechName, const string& initialResponse); shared_ptr <IMAPCommand> IMAPCommand::LIST(const string& refName, const string& mailboxName); shared_ptr <IMAPCommand> IMAPCommand::DELETE(const string& mailboxName); shared_ptr <IMAPCommand> IMAPCommand::STARTTLS(); shared_ptr <IMAPCommand> IMAPCommand::CAPABILITY(); shared_ptr <IMAPCommand> IMAPCommand::NOOP(); shared_ptr <IMAPCommand> IMAPCommand::EXPUNGE(); shared_ptr <IMAPCommand> IMAPCommand::CLOSE(); shared_ptr <IMAPCommand> IMAPCommand::LOGOUT(); const string IMAPCommand::getText(); const string IMAPCommand::getTraceText(); void IMAPCommand::send(shared_ptr <IMAPConnection> conn);

af21b6d6cf1a9b66187152e4e1a2e66d028da6ca876f8c0790f035d931748b11

GOLDELEC

Huan

main/Http2Client.cpp

on_stream_close_callback

static int on_stream_close_callback(nghttp2_session *session, int32_t stream_id, uint32_t error_code, void *user_data) { ESP_LOGI(TAG, "on_stream_close_callback"); Request *req; req = (Request *)nghttp2_session_get_stream_user_data(session, stream_id); if (req) { int rv; rv = nghttp2_session_terminate_session(session, NGHTTP2_NO_ERROR); if (rv != 0) { ESP_LOGE(TAG, "nghttp2_session_terminate_session:%d", rv); } } return 0; }

Http2Client::Http2Client(); Http2Client::~Http2Client(); bool Http2Client::begin(std::string host, std::string path, int port); void Http2Client::performIo(struct Connection *connection); void Http2Client::end(); string Http2Client::getString(void); bool Http2Client:: connected(); void Http2Client::setTimeout(int timeout); int Http2Client::getimeout(); bool Http2Client::connectToServer(void); static ssize_t send_callback(nghttp2_session *session, const uint8_t *data, size_t length, int flags, void *user_data); static ssize_t recv_callback(nghttp2_session *session, uint8_t *buf, size_t length, int flags, void *user_data); static int on_frame_send_callback(nghttp2_session *session, const nghttp2_frame *frame, void *user_data); static int on_frame_recv_callback(nghttp2_session *session, const nghttp2_frame *frame, void *user_data); void Http2Client::setupNghttp2Callbacks(nghttp2_session_callbacks *callbacks); void Http2Client::submitRequest(struct Connection *connection, struct Request *req); bool Http2Client::initNghttp2();

763dc3016a66723b70284734d87ae1553514b2cdb4f83ee10d4c25da92dd934d

Ansa89

qTox

src/audio/audio.cpp

Audio::closeOutput

void Audio::closeOutput() { qDebug() << "Closing output"; QMutexLocker lock(audioOutLock); if (alContext && alcMakeContextCurrent(nullptr) == ALC_TRUE) alcDestroyContext(alContext); if (alOutDev) { if (alcCloseDevice(alOutDev) == ALC_TRUE) alOutDev = nullptr; else qWarning() << "Failed to close output"; } }

Audio& Audio::getInstance(); Audio::~Audio(); float Audio::getOutputVolume(); void Audio::setOutputVolume(float volume); void Audio::suscribeInput(); void Audio::unsuscribeInput(); void Audio::openInput(const QString& inDevDescr); void Audio::openOutput(const QString& outDevDescr); void Audio::closeInput(); void Audio::playMono16Sound(const QByteArray& data); void Audio::playGroupAudioQueued(Tox*,int group, int peer, const int16_t* data, unsigned samples, uint8_t channels, unsigned sample_rate, void* core); void Audio::playGroupAudio(int group, int peer, const int16_t* data, unsigned samples, uint8_t channels, unsigned sample_rate); void Audio::playAudioBuffer(ALuint alSource, const int16_t *data, int samples, unsigned channels, int sampleRate); bool Audio::isInputReady(); bool Audio::isOutputClosed(); bool Audio::tryCaptureSamples(uint8_t* buf, int framesize); void Audio::getEchoesToFilter(AudioFilterer* filterer, int framesize);

eeef2e9a4f3408370771c66154778edb392ef3ded5f7ffb3d1e3d2ace273a9fc

jbaayen

vortexje

vortexje/empirical-wakes/ramasamy-leishman-wake.cpp

Vector3d RamasamyLeishmanWake::vortex_ring_unit_velocity

Vector3d RamasamyLeishmanWake::vortex_ring_unit_velocity(const Eigen::Vector3d &x, int this_panel) const { if (this_panel >= n_panels() - lifting_surface->n_spanwise_panels()) { return this->Surface::vortex_ring_unit_velocity(x, this_panel); } double vortex_reynolds_number = doublet_coefficients[this_panel] / RamasamyLeishmanWake::Parameters::fluid_kinematic_viscosity; int less_than_idx; for (less_than_idx = 0; less_than_idx < 12; less_than_idx++) { ramasamy_leishman_data_row &row = ramasamy_leishman_data[less_than_idx]; if (vortex_reynolds_number < row.vortex_reynolds_number) break; } double a[3]; double b[3]; if (less_than_idx == 0) { a[0] = ramasamy_leishman_data[0].a_1; a[1] = ramasamy_leishman_data[0].a_2; b[0] = ramasamy_leishman_data[0].b_1; b[1] = ramasamy_leishman_data[0].b_2; b[2] = ramasamy_leishman_data[0].b_3; } else if (less_than_idx == 12) { a[0] = ramasamy_leishman_data[11].a_1; a[1] = ramasamy_leishman_data[11].a_2; b[0] = ramasamy_leishman_data[11].b_1; b[1] = ramasamy_leishman_data[11].b_2; b[2] = ramasamy_leishman_data[11].b_3; } else { double one_over_delta_vortex_reynolds_number = 1.0 / (ramasamy_leishman_data[less_than_idx].vortex_reynolds_number - ramasamy_leishman_data[less_than_idx - 1].vortex_reynolds_number); double x = vortex_reynolds_number - ramasamy_leishman_data[less_than_idx - 1].vortex_reynolds_number; double slope; slope = (ramasamy_leishman_data[less_than_idx].a_1 - ramasamy_leishman_data[less_than_idx - 1].a_1) * one_over_delta_vortex_reynolds_number; a[0] = ramasamy_leishman_data[less_than_idx - 1].a_1 + slope * x; slope = (ramasamy_leishman_data[less_than_idx].a_2 - ramasamy_leishman_data[less_than_idx - 1].a_2) * one_over_delta_vortex_reynolds_number; a[1] = ramasamy_leishman_data[less_than_idx - 1].a_2 + slope * x; slope = (ramasamy_leishman_data[less_than_idx].b_1 - ramasamy_leishman_data[less_than_idx - 1].b_1) * one_over_delta_vortex_reynolds_number; b[0] = ramasamy_leishman_data[less_than_idx - 1].b_1 + slope * x; slope = (ramasamy_leishman_data[less_than_idx].b_2 - ramasamy_leishman_data[less_than_idx - 1].b_2) * one_over_delta_vortex_reynolds_number; b[1] = ramasamy_leishman_data[less_than_idx - 1].b_2 + slope * x; slope = (ramasamy_leishman_data[less_than_idx].b_3 - ramasamy_leishman_data[less_than_idx - 1].b_3) * one_over_delta_vortex_reynolds_number; b[2] = ramasamy_leishman_data[less_than_idx - 1].b_3 + slope * x; } a[2] = 1 - a[0] - a[1]; Vector3d velocity(0, 0, 0); for (int i = 0; i < (int) panel_nodes[this_panel].size(); i++) { int previous_idx; if (i == 0) previous_idx = panel_nodes[this_panel].size() - 1; else previous_idx = i - 1; const Vector3d &node_a = nodes[panel_nodes[this_panel][previous_idx]]; const Vector3d &node_b = nodes[panel_nodes[this_panel][i]]; Vector3d r_0 = node_b - node_a; Vector3d r_1 = node_a - x; Vector3d r_2 = node_b - x; double r_0_norm = r_0.norm(); double r_1_norm = r_1.norm(); double r_2_norm = r_2.norm(); Vector3d r_1xr_2 = r_1.cross(r_2); double r_1xr_2_sqnorm = r_1xr_2.squaredNorm(); double r_1xr_2_norm = sqrt(r_1xr_2_sqnorm); if (r_0_norm < Vortexje::Parameters::zero_threshold || r_1_norm < Vortexje::Parameters::zero_threshold || r_2_norm < Vortexje::Parameters::zero_threshold || r_1xr_2_sqnorm < Vortexje::Parameters::zero_threshold) continue; double d = r_1xr_2_norm / r_0_norm; double dr = pow(d / vortex_core_radii[this_panel][i], 2); double sum = 0; for (int j = 0; j < 3; j++) sum += a[j] * exp(-b[j] * dr); velocity += (1 - sum) * r_1xr_2 / r_1xr_2_sqnorm * r_0.dot(r_1 / r_1_norm - r_2 / r_2_norm); } return one_over_4pi * velocity; }

RamasamyLeishmanWake::RamasamyLeishmanWake(std::shared_ptr<LiftingSurface> lifting_surface);

72d3a22ef11267259c562ddd8fe07e986a4b775f28f791fc2e24b0163a895b72

treejames

eva

src/libeva/evaimreceive.cpp

ReceivedSystemIM::parseData

void ReceivedSystemIM::parseData(const unsigned char *buf, const int ) { int pos = 0; systemIMType = buf[pos++]; char msgLen = buf[pos++]; #ifdef WIN32 char* msg; msg=(char*)_alloca(msgLen+1); #else char msg[msgLen+1]; #endif memcpy(msg, buf+pos, msgLen); msg[0xff & msgLen]=0x00; message.assign(msg); }

ReceiveIMPacket::ReceiveIMPacket(unsigned char *buf, const int len); ReceiveIMPacket::ReceiveIMPacket(const ReceiveIMPacket &rhs); std::string ReceiveIMPacket::convertToShow(const std::string &src, const unsigned char type); ReceiveIMPacket &ReceiveIMPacket::operator=(const ReceiveIMPacket &rhs); void ReceiveIMPacket::parseBody(); int ReceiveIMPacket::readHeader(const unsigned char *buf); NormalIMBase::NormalIMBase(const unsigned char *buf, const int len); NormalIMBase::NormalIMBase(const NormalIMBase &rhs); NormalIMBase::~NormalIMBase(); void NormalIMBase::setNormalIMBase(const NormalIMBase *base); void NormalIMBase::parseData(); NormalIMBase &NormalIMBase::operator=(const NormalIMBase &rhs); void NormalIMBase::parseContents(const unsigned char *, const int ); int NormalIMBase::readHeader(const unsigned char *buf); ReceivedNormalIM::ReceivedNormalIM(const unsigned char *buf, const int len); ReceivedNormalIM::ReceivedNormalIM(const ReceivedNormalIM &rhs); const bool ReceivedNormalIM::isNormalReply(); ReceivedNormalIM &ReceivedNormalIM::operator=(const ReceivedNormalIM &rhs); void ReceivedNormalIM::parseContents(const unsigned char *buf, const int len); ReceivedSystemIM::ReceivedSystemIM(const unsigned char *buf, const int len); ReceivedSystemIM::ReceivedSystemIM( const ReceivedSystemIM &rhs); ReceivedSystemIM &ReceivedSystemIM::operator=(const ReceivedSystemIM &rhs); ReceiveIMReplyPacket::ReceiveIMReplyPacket(const char *key); ReceiveIMReplyPacket::ReceiveIMReplyPacket(const ReceiveIMReplyPacket &rhs); ReceiveIMReplyPacket &ReceiveIMReplyPacket::operator=(const ReceiveIMReplyPacket &rhs); int ReceiveIMReplyPacket::putBody(unsigned char *buf); ReceivedQunIM::ReceivedQunIM(const unsigned short src, const unsigned char * buf, const int len ); ReceivedQunIM::ReceivedQunIM( const ReceivedQunIM & rhs ); ReceivedQunIM & ReceivedQunIM::operator =( const ReceivedQunIM & rhs ); void ReceivedQunIM::parseData( const unsigned char * buf, const int len ); ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest(); ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest(const unsigned short imType, const unsigned char * buf, const int len); ReceivedQunIMJoinRequest::ReceivedQunIMJoinRequest( const ReceivedQunIMJoinRequest & rhs ); ReceivedQunIMJoinRequest::~ReceivedQunIMJoinRequest(); ReceivedQunIMJoinRequest & ReceivedQunIMJoinRequest::operator =( const ReceivedQunIMJoinRequest & rhs ); void ReceivedQunIMJoinRequest::setCode(const unsigned char *code, const unsigned short len); void ReceivedQunIMJoinRequest::setToken(const unsigned char *token, const unsigned short len); SignatureChangedPacket::SignatureChangedPacket( const unsigned char * buf, const int len ); SignatureChangedPacket::SignatureChangedPacket( const SignatureChangedPacket & rhs ); SignatureChangedPacket & SignatureChangedPacket::operator =( const SignatureChangedPacket & rhs ); void SignatureChangedPacket::parseData( const unsigned char * buf, const int /*len*/ ); ReceivedFileIM::ReceivedFileIM( const unsigned char * buf, const int len ); ReceivedFileIM::ReceivedFileIM( const ReceivedFileIM & rhs ); ReceivedFileIM & ReceivedFileIM::operator =( const ReceivedFileIM & rhs ); void ReceivedFileIM::parseContents( const unsigned char * buf, const int len ); ReceivedFileExIpIM::ReceivedFileExIpIM( const unsigned char * buf, const int len ); ReceivedFileExIpIM::ReceivedFileExIpIM( const ReceivedFileExIpIM & rhs ); ReceivedFileExIpIM & ReceivedFileExIpIM::operator =( const ReceivedFileExIpIM & rhs ); void ReceivedFileExIpIM::parseContents( const unsigned char * buf, const int len ); ReceivedQQNews::ReceivedQQNews( const unsigned char * buf, const int len ); ReceivedQQNews::ReceivedQQNews( const ReceivedQQNews & rhs ); ReceivedQQNews & ReceivedQQNews::operator =( const ReceivedQQNews & rhs ); void ReceivedQQNews::parseData( const unsigned char * buf, const int /*len*/ );

8c7a54a939a6ad26bb59267a1fc1a40f484a5f64f6baacb0eaa365225e2d17c6

jar1karp

rstudio

src/cpp/session/SessionModuleContext.cpp

fileListingFilter

bool fileListingFilter(const core::FileInfo& fileInfo) { core::FilePath filePath(fileInfo.absolutePath()); std::string ext = filePath.extensionLowerCase(); std::string name = filePath.filename(); if (ext == ".r" || ext == ".rprofile" || ext == ".rbuildignore" || ext == ".rdata" || ext == ".rhistory" || ext == ".ruserdata" || ext == ".renviron" || ext == ".httr-oauth" || ext == ".gitignore") { return true; } else if (name == ".travis.yml") { return true; } else if (userSettings().hideObjectFiles() && (ext == ".o" || ext == ".so" || ext == ".dll") && filePath.parent().filename() == "src") { return false; } else { return !filePath.isHidden(); } }

SEXP rs_enqueClientEvent(SEXP nameSEXP, SEXP dataSEXP); SEXP rs_activatePane(SEXP paneSEXP); SEXP rs_showErrorMessage(SEXP titleSEXP, SEXP messageSEXP); SEXP rs_logErrorMessage(SEXP messageSEXP); SEXP rs_logWarningMessage(SEXP messageSEXP); SEXP rs_threadSleep(SEXP secondsSEXP); SEXP rs_rstudioProgramMode(); SEXP rs_rstudioEdition(); SEXP rs_rstudioVersion(); SEXP rs_rstudioCitation(); SEXP rs_setUsingMingwGcc49(SEXP usingSEXP); SEXP rs_ensureFileHidden(SEXP fileSEXP); SEXP rs_sourceDiagnostics(); SEXP rs_packageLoaded(SEXP pkgnameSEXP); SEXP rs_packageUnloaded(SEXP pkgnameSEXP); SEXP rs_restartR(SEXP afterRestartSEXP); SEXP rs_generateShortUuid(); FilePath monitoredParentPath(); bool monitoredScratchFilter(const FileInfo& fileInfo); void onFilesChanged(const std::vector<core::system::FileChangeEvent>& changes); boost::shared_ptr<tree<FileInfo> > monitoredPathTree(); bool scanForMonitoredPathChanges(boost::shared_ptr<tree<FileInfo> > pPrevTree); void onMonitoringError(const Error& error); void initializeMonitoredUserScratchDir(); void add(const SuspendHandler& handler); void suspend(const r::session::RSuspendOptions& options, Settings* pSettings); void resume(const Settings& settings); void addSuspendHandler(const SuspendHandler& handler); void onResumed(const Settings& persistentState); void executeScheduledCommands(ScheduledCommands* pCommands); bool performDelayedWork(const boost::function<void(); bool isPackagePosixMakefile(const FilePath& srcPath); void onBackgroundProcessing(bool isIdle); core::string_utils::LineEnding lineEndings(const core::FilePath& srcFile); FilePath userHomePath(); std::string createAliasedPath(const FileInfo& fileInfo); std::string createAliasedPath(const FilePath& path); FilePath resolveAliasedPath(const std::string& aliasedPath); FilePath userScratchPath(); FilePath scopedScratchPath(); FilePath sharedScratchPath(); FilePath sessionScratchPath(); FilePath oldScopedScratchPath(); bool isVisibleUserFile(const FilePath& filePath); FilePath safeCurrentPath(); FilePath tempFile(const std::string& prefix, const std::string& extension); FilePath tempDir(); FilePath findProgram(const std::string& name); bool isPdfLatexInstalled(); bool hasTextMimeType(const FilePath& filePath); bool hasBinaryMimeType(const FilePath& filePath); bool isJsonFile(const FilePath& filePath); bool isTextFile(const FilePath& targetPath); Error rBinDir(core::FilePath* pRBinDirPath); Error rScriptPath(FilePath* pRScriptPath); shell_utils::ShellCommand rCmd(const core::FilePath& rBinDir); std::string rLocalHelpPort(); std::vector<FilePath> getLibPaths(); bool disablePackages(); bool isPackageInstalled(const std::string& packageName); bool isMinimumDevtoolsInstalled(); bool isMinimumRoxygenInstalled(); std::string packageVersion(const std::string& packageName); bool hasMinimumRVersion(const std::string &version); Error installPackage(const std::string& pkgPath, const std::string& libPath); std::string packageNameForSourceFile(const core::FilePath& sourceFilePath); bool isUnmonitoredPackageSourceFile(const FilePath& filePath); SEXP rs_packageNameForSourceFile(SEXP sourceFilePathSEXP); SEXP rs_base64encode(SEXP dataSEXP, SEXP binarySEXP); SEXP rs_base64decode(SEXP dataSEXP, SEXP binarySEXP); json::Object createFileSystemItem(const FileInfo& fileInfo); json::Object createFileSystemItem(const FilePath& filePath); std::string rVersion(); std::string rHomeDir(); r_util::ActiveSession& activeSession(); r_util::ActiveSessions& activeSessions(); std::string libPathsString(); Error sourceModuleRFile(const std::string& rSourceFile); void enqueClientEvent(const ClientEvent& event); bool isDirectoryMonitored(const FilePath& directory); bool isRScriptInPackageBuildTarget(const FilePath &filePath); SEXP rs_isRScriptInPackageBuildTarget(SEXP filePathSEXP); void enqueFileChangedEvent(const core::system::FileChangeEvent &event); void consoleWriteOutput(const std::string& output); void consoleWriteError(const std::string& message); void showErrorMessage(const std::string& title, const std::string& message); void showFile(const FilePath& filePath, const std::string& window); std::string createFileUrl(const core::FilePath& filePath); void showContent(const std::string& title, const core::FilePath& filePath); std::string resourceFileAsString(const std::string& fileName); bool portmapPathForLocalhostUrl(const std::string& url, std::string* pPath); std::string mapUrlPorts(const std::string& url); void activatePane(const std::string& pane); FilePath shellWorkingDirectory(); Events& events(); core::system::ProcessSupervisor& processSupervisor(); FilePath sourceDiagnostics(); core::json::Object compileOutputAsJson(const CompileOutput& compileOutput); std::string CRANReposURL(); std::string rstudioCRANReposURL(); SEXP rs_rstudioCRANReposUrl(); std::string downloadFileMethod(const std::string& defaultMethod); std::string CRANDownloadOptions(); bool haveSecureDownloadFileMethod(); shell_utils::ShellCommand RCommand::buildRCmd(const core::FilePath& rBinDir); std::string sessionTempDirUrl(const std::string& sessionTempPath); bool hasStem(const FilePath& filePath, const std::string& stem); bool isUserFile(const FilePath& filePath); json::Value sourceMarkerJson(const SourceMarker& sourceMarker); json::Array sourceMarkersAsJson(const std::vector<SourceMarker>& markers); SourceMarker::Type sourceMarkerTypeFromString(const std::string& type); bool isLoadBalanced(); bool usingMingwGcc49(); bool usingMingwGcc49(); Error initialize();

8065f11388cd2c7b7041a1e09f8cc103fd34dd430a371ca69c8820377c2685e7

OTSimulation

otSim

3rdparty/gnsstk/Matrix.cpp

operator*

Matrix operator* (const Matrix& mat1, const Matrix& mat2) { Matrix A; if (!MTX_Multiply(&A.m_Matrix, &mat1.m_Matrix, &mat2.m_Matrix)) { A.Clear(); Matrix::StaticMatrixError("operator*", "MTX_Multiply() returned false."); return A; } return A; }

MatrixException::MatrixException(const char* msg); MatrixException::MatrixException(const MatrixException& matrix_exception); std::string MatrixException::GetExceptionMessage(); MatrixException::operator const char*(); Matrix::Matrix(); Matrix::~Matrix(); Matrix::Matrix(const unsigned nrows); Matrix::Matrix(const unsigned nrows, const unsigned ncols, const bool isReal); Matrix::Matrix(const char* path, bool& itWorked); Matrix::Matrix(const Matrix& mat); Matrix::Matrix(const double mat[], const unsigned nrows, const unsigned ncols); Matrix::Matrix(const char* strMatrix); Matrix& Matrix::operator= (const Matrix& mat); Matrix& Matrix::operator= (const double value); Matrix& Matrix::operator= (const std::complex<double> value); Matrix& Matrix::operator=(const char* strMatrix); bool Matrix::Clear(); void Matrix::MatrixError(const char* error); void Matrix::MatrixError(const char* function, const char* error); void Matrix::StaticMatrixError(const char* error); void Matrix::StaticMatrixError(const char* function, const char* error); bool Matrix::isEmpty(); bool Matrix::isConformal(const Matrix& mat); bool Matrix::isSameSize(const Matrix& mat); bool Matrix::isSquare(); unsigned Matrix::GetNrCols(); unsigned Matrix::ncols(); unsigned Matrix::GetNrElems(); unsigned Matrix::nelems(); unsigned Matrix::GetNrRows(); unsigned Matrix::nrows(); unsigned Matrix::GetLength(); double Matrix::real(const unsigned row, const unsigned col); double Matrix::real(const unsigned index); double Matrix::imag(const unsigned row, const unsigned col); double Matrix::imag(const unsigned index); bool Matrix::isStoredAsComplex(); bool Matrix::isReal(); bool Matrix::isComplex(); bool Matrix::isVector(); bool Matrix::ReadFromFile(const char *path); bool Matrix::ReadFromFile(std::string path); bool Matrix::Copy(Matrix& src); bool Matrix::Copy(const double& value); bool Matrix::Copy(const std::complex<double>& cplx); bool Matrix::Save(const char* path); bool Matrix::Save(std::string path); bool Matrix::Print(const char *path, const unsigned precision, bool append); bool Matrix::Print(std::string path, const unsigned precision, bool append); bool Matrix::PrintStdout(const unsigned precision); bool Matrix::PrintToBuffer(char* buffer, const unsigned maxlength, const unsigned precision); bool Matrix::PrintFixedWidth(const char* path, const unsigned width, const unsigned precision, bool append); bool Matrix::PrintFixedWidth(std::string path, const unsigned width, const unsigned precision, bool append); bool Matrix::PrintFixedWidthToBuffer(char* buffer, const unsigned maxlength, const unsigned width, const unsigned precision); bool Matrix::PrintDelimited(const char *path, const unsigned precision, const char delimiter, bool append); bool Matrix::PrintDelimited(std::string path, const unsigned precision, const char delimiter, bool append); bool Matrix::PrintDelimitedToBuffer(char *buffer, const unsigned maxlength, const unsigned precision, const char delimiter); bool Matrix::PrintRowToString(const unsigned row, char *buffer, const unsigned maxlength, const int width, const int precision); bool Matrix::RemoveColumn(const unsigned col); bool Matrix::RemoveColumnsAfterIndex(const unsigned col); bool Matrix::RemoveRowsAndColumns(const unsigned nrows, const unsigned rows[], const unsigned ncols, const unsigned cols[]); bool Matrix::InsertColumn(const Matrix &src, const unsigned dst_col, const unsigned src_col); bool Matrix::AddColumn(const Matrix &src, const unsigned src_col); bool Matrix::Concatonate(const Matrix &src); bool Matrix::Redim(const unsigned nrows, const unsigned ncols); bool Matrix::Resize(const unsigned nrows, const unsigned ncols); bool Matrix::SetFromStaticMatrix(const double mat[], const unsigned nrows, const unsigned ncols); bool Matrix::SetFromMatrixString(const char* strMatrix); bool Matrix::CopyColumn(const unsigned src_col, Matrix &dst); bool Matrix::InsertSubMatrix(const Matrix &src, const unsigned dst_row, const unsigned dst_col); bool Matrix::Zero(); bool Matrix::ZeroColumn(const unsigned col); bool Matrix::ZeroRow(const unsigned row); bool Matrix::Swap(Matrix &M); bool Matrix::Fill(const double value); bool Matrix::FillColumn(const unsigned col, const double value); bool Matrix::FillRow(const unsigned row, const double value); bool Matrix::FlipColumn(const unsigned col); bool Matrix::FlipRow(const unsigned row); bool Matrix::Identity(); bool Matrix::Identity(const unsigned dimension); bool Matrix::Inplace_ForceSymmetric(); bool Matrix::Inplace_Transpose(); bool Matrix::Inplace_Round(const unsigned precision); bool Matrix::Inplace_Floor(); bool Matrix::Inplace_Ceil(); bool Matrix::Inplace_erf(); bool Matrix::Inplace_erfinv(); bool Matrix::Inplace_erfc(); bool Matrix::Inplace_Fix(); bool Matrix::Inplace_AddScalar(const double scalar); bool Matrix::Inplace_SubtractScalar(const double scalar); bool Matrix::Inplace_MultiplyScalar(const double scalar); bool Matrix::Inplace_DivideScalar(const double scalar); bool Matrix::Inplace_PowerScalar(const double scalar); bool Matrix::Inplace_AddScalarComplex(const std::complex<double> cplx); bool Matrix::Inplace_SubtractScalarComplex(const std::complex<double> cplx); bool Matrix::Inplace_MultiplyScalarComplex(const std::complex<double> cplx); bool Matrix::Inplace_DivideScalarComplex(const std::complex<double> cplx); bool Matrix::Inplace_PowerScalarComplex(const std::complex<double> cplx); bool Matrix::Inplace_Abs(); bool Matrix::Inplace_acos(); bool Matrix::Inplace_acosd(); bool Matrix::Inplace_acosh(); bool Matrix::Inplace_angle(); bool Matrix::Inplace_asin(); bool Matrix::Inplace_asind(); bool Matrix::Inplace_asinh(); bool Matrix::Inplace_atan(); bool Matrix::Inplace_atand(); bool Matrix::Inplace_atanh(); bool Matrix::Inplace_Sqr(); bool Matrix::Inplace_Sqrt(); bool Matrix::Inplace_Exp(); bool Matrix::Inplace_Ln(); bool Matrix::Inplace_Increment(); bool Matrix::Inplace_Decrement(); bool Matrix::Inplace_Add(const Matrix &B); bool Matrix::Inplace_Subtract(const Matrix &B); bool Matrix::Inplace_PreMultiply(const Matrix &B); bool Matrix::Inplace_TranposePreMultiply(const Matrix &B); bool Matrix::Inplace_PostMultiply(const Matrix &B); bool Matrix::Inplace_PostMultiplyTranspose(const Matrix &B); bool Matrix::Inplace_DotMultiply(const Matrix &B); bool Matrix::Inplace_DotDivide(const Matrix &B); bool Matrix::Inplace_SortAscending(); bool Matrix::Inplace_SortDescending(); bool Matrix::Inplace_SortColumnAscending(const unsigned col); bool Matrix::Inplace_SortColumnDescending(const unsigned col); bool Matrix::Inplace_SortColumnIndexed(const unsigned col, Matrix &Index); bool Matrix::Inplace_SortByColumn(const unsigned col); bool Matrix::Inplace_Invert(); bool Matrix::Inplace_InvertRobust(); bool Matrix::Inplace_LowerTriangularInverse(); bool Matrix::Inplace_FFT(); bool Matrix::Inplace_FFT2(); bool Matrix::Inplace_IFFT(); bool Matrix::Inplace_IFFT2(); bool Matrix::Add(const Matrix &B, const Matrix &C); bool Matrix::Subtract(const Matrix &B, const Matrix &C); bool Matrix::Multiply(const Matrix &B, const Matrix &C); bool Matrix::TransposeMultiply(const Matrix &B, const Matrix &C); bool Matrix::MultiplyTranspose(const Matrix &B, const Matrix &C); bool Matrix::Inplace_abs(); bool Matrix::Inplace_colon(double start, double increment, double end); bool Matrix::Inplace_conj(); bool Matrix::Inplace_cos(); bool Matrix::Inplace_cosh(); bool Matrix::Inplace_cot(); bool Matrix::Inplace_coth(); bool Matrix::Inplace_imag(); bool Matrix::Inplace_exp(); bool Matrix::Inplace_eye(const unsigned nrows, const unsigned ncols); bool Matrix::Inplace_log2(); bool Matrix::Inplace_log10(); bool Matrix::Inplace_ones(const unsigned nrows, const unsigned ncols); bool Matrix::Inplace_real(); bool Matrix::Inplace_rand(const unsigned nrows, const unsigned ncols, const unsigned seed); bool Matrix::Inplace_randn(const unsigned nrows, const unsigned ncols, const unsigned seed); bool Matrix::Inplace_sin(); bool Matrix::Inplace_sinc(); bool Matrix::Inplace_sinh(); bool Matrix::Inplace_sqrt(); bool Matrix::Inplace_tan(); bool Matrix::Inplace_tanh(); bool Matrix::Inplace_zeros(const unsigned nrows, const unsigned ncols); bool Matrix::GetStats_MaxAbs(unsigned &row, unsigned &col, double &value); bool Matrix::GetStats_Max(unsigned &row, unsigned &col, double &re, double &im); bool Matrix::GetStats_MaxVal(double &re, double &im); bool Matrix::GetStats_MaxAbsCol(const unsigned col, double &value, unsigned &row); bool Matrix::GetStats_MaxCol(const unsigned col, double &re, double &im, unsigned &row); bool Matrix::GetStats_MaxColVal(const unsigned col, double &re, double &im); bool Matrix::GetStats_MaxAbsRow(const unsigned row, double &value, unsigned &col); bool Matrix::GetStats_MaxRow(const unsigned row, double &re, double &im, unsigned &col); bool Matrix::GetStats_MaxRowVal(const unsigned row, double &re, double &im); bool Matrix::GetStats_MinAbs(unsigned &row, unsigned &col, double &value); bool Matrix::GetStats_Min(unsigned &row, unsigned &col, double &re, double &im); bool Matrix::GetStats_MinVal(double &re, double &im); bool Matrix::GetStats_MinAbsCol(const unsigned col, double &value, unsigned &row); bool Matrix::GetStats_MinCol(const unsigned col, double &re, double &im, unsigned &row); bool Matrix::GetStats_MinColVal(const unsigned col, double &re, double &im); bool Matrix::GetStats_MinAbsRow(const unsigned row, double &value, unsigned &col); bool Matrix::GetStats_MinRow(const unsigned row, double &re, double &im, unsigned &col); bool Matrix::GetStats_MinRowVal(const unsigned row, double &re, double &im); bool Matrix::GetStats_ColRange(const unsigned col, double &re, double &im); bool Matrix::GetStats_RowRange(const unsigned row, double &re, double &im); bool Matrix::GetStats_Range(double &re, double &im); bool Matrix::GetStats_ColumnSum(const unsigned col, double &re, double &im); bool Matrix::GetStats_RowSum(const unsigned row, double &re, double &im); bool Matrix::GetStats_Sum(double &re, double &im); bool Matrix::GetStats_ColumnMean(const unsigned col, double &re, double &im); bool Matrix::GetStats_RowMean(const unsigned row, double &re, double &im); bool Matrix::GetStats_Mean(double &re, double &im); bool Matrix::GetStats_ColumnStdev(const unsigned col, double &value); bool Matrix::GetStats_RowStdev(const unsigned row, double &value); bool Matrix::GetStats_Stdev(double &value); bool Matrix::GetStats_ColumnVar(const unsigned col, double &value); bool Matrix::GetStats_RowVar(const unsigned row, double &value); bool Matrix::GetStats_Var(double &value); bool Matrix::GetStats_ColumnNorm(const unsigned col, double &value); bool Matrix::GetStats_RowNorm(const unsigned row, double &value); bool Matrix::GetStats_Norm(double &value); bool Matrix::GetStats_ColumnRMS(const unsigned col, double &value); bool Matrix::GetStats_RowRMS(const unsigned row, double &value); bool Matrix::GetStats_RMS(double &value); bool Matrix::GetStats_ColumnSkewness(const unsigned col, double &re, double &im); bool Matrix::GetStats_RowSkewness(const unsigned row, double &re, double &im); bool Matrix::GetStats_Skewness(double &re, double &im); bool Matrix::GetStats_ColumnKurtosis(const unsigned col, double &re, double &im); bool Matrix::GetStats_RowKurtosis(const unsigned row, double &re, double &im); bool Matrix::GetStats_Kurtosis(double &re, double &im); bool Matrix::GetTrace(double &re, double &im); bool Matrix::GetDeterminant(double &re, double &im); bool Matrix::GetDiagonal(Matrix& DiagonalVector); bool Matrix::GetColumnMovAvg(const unsigned col, const unsigned lead, const unsigned lag, Matrix &MovAvg); bool Matrix::GetMovAvg(const unsigned lead, const unsigned lag, Matrix &MovAvg); bool Matrix::GetATAInverse(Matrix &InvATA); bool Matrix::GetLUFactorization(bool &isFullRank, Matrix &P, Matrix &L, Matrix &U); bool Matrix::GetIndexedValues(Matrix& RowIndex, Matrix& ColIndex, Matrix& Result); bool Matrix::SetIndexedValues(Matrix& RowIndex, Matrix& ColIndex, Matrix& SourceData); std::string Matrix::GetMatrixComment(); Matrix Matrix::Column(const unsigned col); Matrix Matrix::Row(const unsigned row); Matrix Matrix::Transpose(); Matrix Matrix::T(); Matrix Matrix::Diagonal(); Matrix Matrix::Inverse(); Matrix Matrix::Inv(); Matrix Matrix::FFT(); Matrix Matrix::FFT2(); Matrix Matrix::IFFT(); Matrix Matrix::IFFT2(); Matrix Matrix::DotMultiply(const Matrix& B); Matrix Matrix::Real(); Matrix Matrix::Imag(); Matrix Matrix::conj(); Matrix Matrix::AddIdentity(); Matrix Matrix::MinusIdentity(); Matrix Matrix::IdentityMinusMe(); Matrix Matrix::Negate(); Matrix Matrix::Sqrt(); Matrix Matrix::Exp(); Matrix Matrix::Ln(); Matrix Matrix::cos(); Matrix Matrix::acos(); Matrix Matrix::sin(); Matrix Matrix::asin(); Matrix Matrix::tan(); Matrix Matrix::atan(); Matrix Matrix::cosh(); Matrix Matrix::sinh(); Matrix Matrix::tanh(); Matrix Matrix::cot(); Matrix Matrix::coth(); Matrix Matrix::abs(); Matrix Matrix::angle(); Matrix Matrix::pow(const double power_re, const double power_im); Matrix Matrix::round(const unsigned precision); Matrix Matrix::floor(); Matrix Matrix::ceil(); Matrix Matrix::fix(); Matrix Matrix::dotInvert(); Matrix Matrix::oneMinusMe(); Matrix::Element& Matrix::operator(); Matrix::Element& Matrix::operator(); Matrix::Element::Element(MTX& mtx); Matrix::Element::~Element(); const double Matrix::Element::real(); const double Matrix::Element::imag(); const Matrix::Element& Matrix::Element::operator= (double v); const Matrix::Element& Matrix::Element::operator= (std::complex<double> v); const Matrix::Element& Matrix::Element::operator= (Element v); Matrix::Element::operator const std::complex<double>(); void Matrix::Element::operator+= (const double scalar); void Matrix::Element::operator+= (const std::complex<double>& v); void Matrix::Element::operator+= (const Element& v); void Matrix::Element::operator-= (const double scalar); void Matrix::Element::operator-= (const std::complex<double>& v); void Matrix::Element::operator-= (const Element& v); void Matrix::Element::operator*= (const double scalar); void Matrix::Element::operator*= (const std::complex<double>& v); void Matrix::Element::operator*= (const Element& v); void Matrix::Element::operator/= (const double scalar); void Matrix::Element::operator/= (const std::complex<double>& v); void Matrix::Element::operator/= (const Element& v); const std::complex<double> operator+ (const Matrix::Element& m, double scalar); const std::complex<double> operator+ (const Matrix::Element& a, const Matrix::Element& b); const std::complex<double> operator+ (const Matrix::Element& a, const std::complex<double>& b); const std::complex<double> operator+ (double scalar, const Matrix::Element& m); const std::complex<double> operator+ (const std::complex<double>& b, const Matrix::Element& a); const std::complex<double> operator- (const Matrix::Element& m, double scalar); const std::complex<double> operator- (const Matrix::Element& a, const Matrix::Element& b); const std::complex<double> operator- (const Matrix::Element& a, const std::complex<double>& b); const std::complex<double> operator- (double scalar, const Matrix::Element& m); const std::complex<double> operator- (const std::complex<double>& b, const Matrix::Element& a); const std::complex<double> operator* (const Matrix::Element& m, double scalar); const std::complex<double> operator* (const Matrix::Element& a, const Matrix::Element& b); const std::complex<double> operator* (const Matrix::Element& a, const std::complex<double>& b); const std::complex<double> operator* (double scalar, const Matrix::Element& m); const std::complex<double> operator* (const std::complex<double>& b, const Matrix::Element& a); const std::complex<double> operator/ (const Matrix::Element& m, double scalar); const std::complex<double> operator/ (const Matrix::Element& a, const Matrix::Element& b); const std::complex<double> operator/ (const Matrix::Element& a, const std::complex<double>& b); const std::complex<double> operator/ (double scalar, const Matrix::Element& m); const std::complex<double> operator/ (const std::complex<double>& b, const Matrix::Element& a); const bool operator== (const Matrix::Element& m, double scalar); const bool operator== (const Matrix::Element& a, const Matrix::Element& b); const bool operator== (const Matrix::Element& a, const std::complex<double>& b); const bool operator== (double scalar, const Matrix::Element& m); const bool operator== (const std::complex<double>& b, const Matrix::Element& a); bool Matrix::operator+= (const double scalar); bool Matrix::operator+= (const std::complex<double> cplx); bool Matrix::operator-= (const double scalar); bool Matrix::operator-= (const std::complex<double> cplx); bool Matrix::operator*= (const double scalar); bool Matrix::operator*= (const std::complex<double> cplx); bool Matrix::operator/= (double scalar); bool Matrix::operator/= (const std::complex<double> cplx); bool Matrix::operator+= (const Matrix& mat); bool Matrix::operator-= (const Matrix& mat); Matrix operator++ (Matrix& mat, int); Matrix operator-- (Matrix& mat, int); Matrix operator* (Matrix& mat1, Matrix& mat2); Matrix operator+ (Matrix& mat1, Matrix& mat2); Matrix operator+ (const Matrix& mat1, const Matrix& mat2); Matrix operator- (Matrix& mat1, Matrix& mat2); Matrix operator- (const Matrix& mat1, const Matrix& mat2); Matrix operator^ (Matrix& mat, const double scalar); Matrix operator+ (const double scalar, Matrix& mat); Matrix operator- (const double scalar, Matrix& mat); Matrix operator* (const double scalar, Matrix& mat); Matrix operator/ (Matrix& mat, const double scalar); Matrix operator/ (const double scalar, Matrix& mat); ostream& operator<< (ostream& strm, const Matrix& mat); bool Matrix::IndexCheck(const unsigned row, const unsigned col); bool Matrix::IndexCheck(const unsigned index); Matrix::RealOnlyAccess::RealOnlyAccess(MTX& mtx, const unsigned row); Matrix::RealOnlyAccess::~RealOnlyAccess(); bool Matrix::RealOnlyAccess::IndexCheck(const unsigned row, const unsigned col); bool Matrix::RealOnlyAccess::IndexCheck(const unsigned index); double& Matrix::RealOnlyAccess::operator [] (const unsigned col); Matrix::RealOnlyAccess Matrix::operator[] (const unsigned row); Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(const double value); Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(RealOnlyAccess& rhs); Matrix::RealOnlyAccess& Matrix::RealOnlyAccess::operator=(Matrix::Element& rhs); Matrix::RealOnlyAccess::operator const double(); bool Matrix::RealOnlyAccess::operator+= (const double scalar); bool Matrix::RealOnlyAccess::operator-= (const double scalar); bool Matrix::RealOnlyAccess::operator*= (const double scalar); bool Matrix::RealOnlyAccess::operator/= (double scalar); bool Matrix::Hilbert(const unsigned N);

0b5b6849d0d7c30041b80990e6ff40707335d6b8dbc97957f5b77bc0e44df1bd

zeng-bioinfo

thu-samlib

cst/rbtree.cpp

RBTree::leftRotate

void RBTree::leftRotate(RBNode* x, void (*updateNode)(RBNode* n, RBTree *T)){ RBNode* y = x->right; x->right=y->left; if (y->left != nil) y->left->parent=x; y->parent=x->parent; if (x->parent==this->nil) root=y; else { if (x == x->parent->left) x->parent->left=y; else x->parent->right=y; } y->left=x; x->parent=y; if (updateNode != 0) { updateNode(x, this); updateNode(y, this); } }

void RBTree::checkTree(); void RBTree::rightRotate(RBNode* x, void (*updateNode); void RBTree::rbInsertFixup(RBNode* z, void (*updateNode); void RBTree::rbDeleteFixup(RBNode *x, void (*updateNode); void RBTree::rbDelete(RBNode *z, void (*updateNode); RBNode* RBTree::treeSuccessor(RBNode *x); RBNode* RBTree::treePredeccessor(RBNode *x); RBNode* RBTree::treeMinimum(RBNode *x); RBNode* RBTree::treeMaximum(RBNode *x); bool RBTree::isLeftChild(RBNode *n); bool RBTree::isRightChild(RBNode *n); RBNode* RBTree::findRightSiblingLeaf(RBNode *n); RBNode* RBTree::findLeftSiblingLeaf(RBNode *n); int RBTree::getNodeMaxDepth(RBNode *n); int RBTree::getNodeMinDepth(RBNode *n); void RBTree::printSubTree(RBNode *n); void RBTree::checkSubTree(RBNode *n); void RBTree::checkNode(RBNode *n);

4c033afe33afcbd67d4a869625ef6b0f2aab4abbe83ada679ec0f8d1778e8ef3

SrNetoChan

QGIS

src/app/maptools/qgsmaptoolshapecircle2points.cpp

QgsMapToolShapeCircle2PointsMetadata::category

QgsMapToolShapeAbstract::ShapeCategory QgsMapToolShapeCircle2PointsMetadata::category() const { return QgsMapToolShapeAbstract::ShapeCategory::Circle; }

QString QgsMapToolShapeCircle2PointsMetadata::id(); QString QgsMapToolShapeCircle2PointsMetadata::name(); QIcon QgsMapToolShapeCircle2PointsMetadata::icon(); QgsMapToolShapeAbstract *QgsMapToolShapeCircle2PointsMetadata::factory( QgsMapToolCapture *parentTool ); bool QgsMapToolShapeCircle2Points::cadCanvasReleaseEvent( QgsMapMouseEvent *e, QgsMapToolCapture::CaptureMode mode ); void QgsMapToolShapeCircle2Points::cadCanvasMoveEvent( QgsMapMouseEvent *e, QgsMapToolCapture::CaptureMode mode );

fc9d3eee287b2ee2ade2225c2d6a51117acb54bfde5e786bd3e6074ad62f5865

dudochkin-victor

libgogootouch

src/views/mlistitemview.cpp

MListItemViewPrivate::_q_applyReleasedStyle

void MListItemViewPrivate::_q_applyReleasedStyle() { Q_Q(MListItemView); setSelected(controller->isSelected()); if (!tapAndHoldStarted && controller->graphicsEffect()) controller->setGraphicsEffect(NULL); q->applyStyle(); q->update(); }

MListItemViewPrivate::MListItemViewPrivate(MWidgetController *controller); MListItemViewPrivate::~MListItemViewPrivate(); void MListItemViewPrivate::init(); void MListItemViewPrivate::_q_applyPressedStyle(); void MListItemViewPrivate::click(); void MListItemViewPrivate::longTap(const QPointF &pos); MListItemView::MListItemView(MWidgetController *controller); void MListItemView::mousePressEvent(QGraphicsSceneMouseEvent *event); void MListItemView::mouseReleaseEvent(QGraphicsSceneMouseEvent *event); void MListItemView::mouseMoveEvent(QGraphicsSceneMouseEvent *event); void MListItemView::cancelEvent(MCancelEvent *event); void MListItemView::tapAndHoldGestureEvent(QGestureEvent *event, QTapAndHoldGesture *gesture);

2ba9fb2fefe07bd417835747e2c12c0c7b2284d2a4db9a8cba867936ecc974bf

aporto

arduino

arduino_motor/libraries/PololuWheelEncoders/PololuWheelEncoders.cpp

PololuWheelEncoders::getCountsM1

int PololuWheelEncoders::getCountsM1() { cli(); int tmp = global_counts_m1; sei(); return tmp; }

void encoders_init(unsigned char m1a, unsigned char m1b, unsigned char m2a, unsigned char m2b); int encoders_get_counts_m1(); int encoders_get_counts_m2(); int encoders_get_counts_and_reset_m1(); int encoders_get_counts_and_reset_m2(); int encoders_check_error_m1(); int encoders_check_error_m2(); ISR(PCINT0_vect); static void enable_interrupts_for_pin(unsigned char p); void PololuWheelEncoders::init(unsigned char m1a, unsigned char m1b, unsigned char m2a, unsigned char m2b); int PololuWheelEncoders::getCountsM2(); int PololuWheelEncoders::getCountsAndResetM1(); int PololuWheelEncoders::getCountsAndResetM2(); unsigned char PololuWheelEncoders::checkErrorM1(); unsigned char PololuWheelEncoders::checkErrorM2();

6889f3b72dfda66b575ed0ed1ac019f0697dd14d9fe82dc4b699c2f15e56e9fa

gabeharms

firestorm

indra/newview/llvoavatarself.cpp

LLVOAvatarSelf::dumpWearableInfo

void LLVOAvatarSelf::dumpWearableInfo(LLAPRFile& outfile) { LLAPRFile::tFiletype* file = outfile.getFileHandle(); if (!file) { return; } apr_file_printf( file, "\n<wearable_info>\n" ); LLWearableData *wd = getWearableData(); for (S32 type = 0; type < LLWearableType::WT_COUNT; type++) { const std::string& type_name = LLWearableType::getTypeName((LLWearableType::EType)type); for (U32 j=0; j< wd->getWearableCount((LLWearableType::EType)type); j++) { LLViewerWearable *wearable = gAgentWearables.getViewerWearable((LLWearableType::EType)type,j); apr_file_printf( file, "\n\t <wearable type=\"%s\" name=\"%s\"/>\n", type_name.c_str(), wearable->getName().c_str() ); LLWearable::visual_param_vec_t v_params; wearable->getVisualParams(v_params); for (LLWearable::visual_param_vec_t::iterator it = v_params.begin(); it != v_params.end(); ++it) { LLVisualParam *param = *it; dump_visual_param(file, param, param->getWeight()); } } } apr_file_printf( file, "\n</wearable_info>\n" ); }

BOOL isAgentAvatarValid(); void selfStartPhase(const std::string& phase_name); void selfStopPhase(const std::string& phase_name, bool err_check); void selfClearPhases(); LocalTextureData(); bool output_self_av_texture_diagnostics(); bool update_avatar_rez_metrics(); bool check_for_unsupported_baked_appearance(); void LLVOAvatarSelf::initInstance(); void LLVOAvatarSelf::markDead(); BOOL LLVOAvatarSelf::loadAvatar(); BOOL LLVOAvatarSelf::loadAvatarSelf(); BOOL LLVOAvatarSelf::buildSkeletonSelf(const LLAvatarSkeletonInfo *info); BOOL LLVOAvatarSelf::buildMenus(); void LLVOAvatarSelf::cleanup(); LLVOAvatarSelf::~LLVOAvatarSelf(); BOOL LLVOAvatarSelf::updateCharacter(LLAgent &agent); BOOL LLVOAvatarSelf::isValid(); void LLVOAvatarSelf::idleUpdate(LLAgent &agent, const F64 &time); LLJoint *LLVOAvatarSelf::getJoint(const std::string &name); void LLVOAvatarSelf::resetJointPositions( void ); BOOL LLVOAvatarSelf::setVisualParamWeight(const LLVisualParam *which_param, F32 weight, BOOL upload_bake ); BOOL LLVOAvatarSelf::setVisualParamWeight(const char* param_name, F32 weight, BOOL upload_bake ); BOOL LLVOAvatarSelf::setVisualParamWeight(S32 index, F32 weight, BOOL upload_bake ); BOOL LLVOAvatarSelf::setParamWeight(const LLViewerVisualParam *param, F32 weight, BOOL upload_bake ); void LLVOAvatarSelf::updateVisualParams(); void LLVOAvatarSelf::idleUpdateAppearanceAnimation(); void LLVOAvatarSelf::requestStopMotion(LLMotion* motion); void LLVOAvatarSelf::stopMotionFromSource(const LLUUID& source_id); void LLVOAvatarSelf::setLocalTextureTE(U8 te, LLViewerTexture* image, U32 index); void LLVOAvatarSelf::removeMissingBakedTextures(); void LLVOAvatarSelf::updateRegion(LLViewerRegion *regionp); void LLVOAvatarSelf::idleUpdateTractorBeam(); void LLVOAvatarSelf::restoreMeshData(); void LLVOAvatarSelf::updateAttachmentVisibility(U32 camera_mode); void LLVOAvatarSelf::wearableUpdated( LLWearableType::EType type, BOOL upload_result ); BOOL LLVOAvatarSelf::isWearingAttachment(const LLUUID& inv_item_id); BOOL LLVOAvatarSelf::attachmentWasRequested(const LLUUID& inv_item_id); void LLVOAvatarSelf::addAttachmentRequest(const LLUUID& inv_item_id); void LLVOAvatarSelf::removeAttachmentRequest(const LLUUID& inv_item_id); LLViewerObject* LLVOAvatarSelf::getWornAttachment(const LLUUID& inv_item_id); boost::signals2::connection LLVOAvatarSelf::setAttachmentCallback(const attachment_signal_t::slot_type& cb); LLViewerJointAttachment* LLVOAvatarSelf::getWornAttachmentPoint(const LLUUID& idItem); const std::string LLVOAvatarSelf::getAttachedPointName(const LLUUID& inv_item_id); const LLViewerJointAttachment *LLVOAvatarSelf::attachObject(LLViewerObject *viewer_object); BOOL LLVOAvatarSelf::detachObject(LLViewerObject *viewer_object); BOOL LLVOAvatarSelf::detachAttachmentIntoInventory(const LLUUID &item_id); U32 LLVOAvatarSelf::getNumWearables(LLAvatarAppearanceDefines::ETextureIndex i); void LLVOAvatarSelf::localTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata); BOOL LLVOAvatarSelf::getLocalTextureGL(ETextureIndex type, LLViewerTexture** tex_pp, U32 index); LLViewerFetchedTexture* LLVOAvatarSelf::getLocalTextureGL(LLAvatarAppearanceDefines::ETextureIndex type, U32 index); const LLUUID& LLVOAvatarSelf::getLocalTextureID(ETextureIndex type, U32 index); BOOL LLVOAvatarSelf::isLocalTextureDataAvailable(const LLViewerTexLayerSet* layerset); BOOL LLVOAvatarSelf::isLocalTextureDataFinal(const LLViewerTexLayerSet* layerset); BOOL LLVOAvatarSelf::isAllLocalTextureDataFinal(); BOOL LLVOAvatarSelf::isBakedTextureFinal(const LLAvatarAppearanceDefines::EBakedTextureIndex index); BOOL LLVOAvatarSelf::isTextureDefined(LLAvatarAppearanceDefines::ETextureIndex type, U32 index); BOOL LLVOAvatarSelf::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, U32 index); BOOL LLVOAvatarSelf::isTextureVisible(LLAvatarAppearanceDefines::ETextureIndex type, LLViewerWearable *wearable); void LLVOAvatarSelf::requestLayerSetUploads(); void LLVOAvatarSelf::requestLayerSetUpload(LLAvatarAppearanceDefines::EBakedTextureIndex i); bool LLVOAvatarSelf::areTexturesCurrent(); bool LLVOAvatarSelf::hasPendingBakedUploads(); void LLVOAvatarSelf::invalidateComposite( LLTexLayerSet* layerset, BOOL upload_result ); void LLVOAvatarSelf::invalidateAll(); void LLVOAvatarSelf::setCompositeUpdatesEnabled( bool b ); void LLVOAvatarSelf::setCompositeUpdatesEnabled(U32 index, bool b); bool LLVOAvatarSelf::isCompositeUpdateEnabled(U32 index); void LLVOAvatarSelf::setupComposites(); void LLVOAvatarSelf::updateComposites(); S32 LLVOAvatarSelf::getLocalDiscardLevel(ETextureIndex type, U32 wearable_index); void LLVOAvatarSelf::getLocalTextureByteCount(S32* gl_bytes); void LLVOAvatarSelf::setLocalTexture(ETextureIndex type, LLViewerTexture* src_tex, BOOL baked_version_ready, U32 index); void LLVOAvatarSelf::setBakedReady(LLAvatarAppearanceDefines::ETextureIndex type, BOOL baked_version_exists, U32 index); void LLVOAvatarSelf::dumpLocalTextures(); void LLVOAvatarSelf::onLocalTextureLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src_raw, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata); void LLVOAvatarSelf::setImage(const U8 te, LLViewerTexture *imagep, const U32 index); LLViewerTexture* LLVOAvatarSelf::getImage(const U8 te, const U32 index); void LLVOAvatarSelf::dumpTotalLocalTextureByteCount(); BOOL LLVOAvatarSelf::getIsCloud(); void LLVOAvatarSelf::debugOnTimingLocalTexLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata); void LLVOAvatarSelf::debugTimingLocalTexLoaded(BOOL success, LLViewerFetchedTexture *src_vi, LLImageRaw* src, LLImageRaw* aux_src, S32 discard_level, BOOL final, void* userdata); void LLVOAvatarSelf::debugBakedTextureUpload(EBakedTextureIndex index, BOOL finished); const std::string LLVOAvatarSelf::verboseDebugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset); void LLVOAvatarSelf::dumpAllTextures(); const std::string LLVOAvatarSelf::debugDumpLocalTextureDataInfo(const LLViewerTexLayerSet* layerset); const std::string LLVOAvatarSelf::debugDumpAllLocalTextureDataInfo(); LLSD LLVOAvatarSelf::metricsData(); void result(const LLSD & content); bool LLVOAvatarSelf::updateAvatarRezMetrics(bool force_send); void LLVOAvatarSelf::addMetricsTimerRecord(const LLSD& record); bool operator<(const LLSD& a, const LLSD& b); void LLVOAvatarSelf::sendViewerAppearanceChangeMetrics(); CheckAgentAppearanceServiceResponder(); virtual ~CheckAgentAppearanceServiceResponder(); void result(const LLSD& content); void errorWithContent(U32 status, const std::string& reason, const LLSD& content); static void forceAppearanceUpdate(); void LLVOAvatarSelf::checkForUnsupportedServerBakeAppearance(); const LLUUID& LLVOAvatarSelf::grabBakedTexture(EBakedTextureIndex baked_index); BOOL LLVOAvatarSelf::canGrabBakedTexture(EBakedTextureIndex baked_index); LLLocalTextureObject* LLVOAvatarSelf::getLocalTextureObject(LLAvatarAppearanceDefines::ETextureIndex i, U32 wearable_index); ETextureIndex LLVOAvatarSelf::getBakedTE( const LLViewerTexLayerSet* layerset ); void LLVOAvatarSelf::setNewBakedTexture(LLAvatarAppearanceDefines::EBakedTextureIndex i, const LLUUID &uuid); void LLVOAvatarSelf::setNewBakedTexture( ETextureIndex te, const LLUUID& uuid ); void LLVOAvatarSelf::outputRezDiagnostics(); void LLVOAvatarSelf::outputRezTiming(const std::string& msg); void LLVOAvatarSelf::reportAvatarRezTime(); void LLVOAvatarSelf::setCachedBakedTexture( ETextureIndex te, const LLUUID& uuid ); void LLVOAvatarSelf::processRebakeAvatarTextures(LLMessageSystem* msg, void**); void LLVOAvatarSelf::forceBakeAllTextures(bool slam_for_debug); void LLVOAvatarSelf::requestLayerSetUpdate(ETextureIndex index ); LLViewerTexLayerSet* LLVOAvatarSelf::getLayerSet(ETextureIndex index); LLViewerTexLayerSet* LLVOAvatarSelf::getLayerSet(EBakedTextureIndex baked_index); void LLVOAvatarSelf::onCustomizeStart(bool disable_camera_switch); void LLVOAvatarSelf::onCustomizeEnd(bool disable_camera_switch); bool LLVOAvatarSelf::sendAppearanceMessage(LLMessageSystem *mesgsys); BOOL LLVOAvatarSelf::needsRenderBeam(); void LLVOAvatarSelf::deleteScratchTextures(); void LLVOAvatarSelf::dumpScratchTextureByteCount(); F32 LLVOAvatarSelf::getAvatarOffset();

4380424a7fa4d188259c2464d5f34960aef7b2c029f43758b91dfb084d861961

pombredanne

metamorphosys-desktop

metamorphosys/tonka/models/SystemC/systemc-2.3.0/src/sysc/kernel/sc_method_process.cpp

sc_method_process::kill_process

void sc_method_process::kill_process(sc_descendant_inclusion_info descendants) { if ( sc_get_status() == SC_ELABORATION ) { report_error( SC_ID_KILL_PROCESS_WHILE_UNITIALIZED_ ); } if ( descendants == SC_INCLUDE_DESCENDANTS ) { const std::vector<sc_object*> children = get_child_objects(); int child_n = children.size(); for ( int child_i = 0; child_i < child_n; child_i++ ) { sc_process_b* child_p = DCAST<sc_process_b*>(children[child_i]); if ( child_p ) child_p->kill_process(descendants); } } if ( m_unwinding ) { SC_REPORT_WARNING( SC_ID_PROCESS_ALREADY_UNWINDING_, name() ); return; } if ( m_state & ps_bit_zombie ) return; if ( next_runnable() != 0 ) simcontext()->remove_runnable_method( this ); disconnect_process(); m_throw_status = THROW_KILL; if ( sc_get_current_process_b() == this ) { throw sc_unwind_exception( this, false ); } }

void sc_method_process::check_for_throws(); void sc_method_process::clear_trigger(); sc_method_process::~sc_method_process(); void sc_method_process::throw_reset( bool async ); bool sc_method_process::trigger_dynamic( sc_event* e );

5700b43967b427b60857e11405d8c3b5dfe718bd15f4b9e7d0122dd86842a2c3

alinous-core

alinous-elastic-db

lib/src_java/alinous.runtime.parallel/SequentialBackgroundJob.cpp

SequentialBackgroundJob::~SequentialBackgroundJob

SequentialBackgroundJob::~SequentialBackgroundJob() throw() { ThreadContext *ctx = ThreadContext::getCurentContext(); if(ctx != nullptr){ctx->incGcDenial();} __releaseRegerences(false, ctx); if(ctx != nullptr){ctx->decGcDenial();} }

bool SequentialBackgroundJob::__init_static_variables(); SequentialBackgroundJob::SequentialBackgroundJob(ThreadContext* ctx); void SequentialBackgroundJob::__construct_impl(ThreadContext* ctx); void SequentialBackgroundJob::__releaseRegerences(bool prepare, ThreadContext* ctx); SequentialBackgroundJob* SequentialBackgroundJob::init(ThreadPool* pool, ThreadContext* ctx); void SequentialBackgroundJob::addJob(IThreadAction* action, ThreadContext* ctx); void SequentialBackgroundJob::execLoop(LaunchJoin* launchJoin, ThreadContext* ctx); void SequentialBackgroundJob::joinAndEnd(ThreadContext* ctx); Throwable* SequentialBackgroundJob::getLastException(ThreadContext* ctx); void SequentialBackgroundJob::__cleanUp(ThreadContext* ctx); bool SequentialBackgroundJob::QueueExecutor::__init_static_variables(); SequentialBackgroundJob::QueueExecutor::QueueExecutor(LaunchJoin* launchJoin, SequentialBackgroundJob* _this, ThreadContext* ctx); void SequentialBackgroundJob::QueueExecutor::__construct_impl(LaunchJoin* launchJoin, SequentialBackgroundJob* _this, ThreadContext* ctx); SequentialBackgroundJob::QueueExecutor::~QueueExecutor(); void SequentialBackgroundJob::QueueExecutor::__releaseRegerences(bool prepare, ThreadContext* ctx); void SequentialBackgroundJob::QueueExecutor::execute(ThreadContext* ctx); void SequentialBackgroundJob::QueueExecutor::__cleanUp(ThreadContext* ctx);

f8379764912f5bb74b7493565444c82d232cdc3c313e2d31b44bd6d1eb045f0e

JTippetts

U3DTerrainEditor

Source/UI/alphabrushselectorui.cpp

AlphaBrushSelectorUI::SetSelected

void AlphaBrushSelectorUI::SetSelected(AlphaEntry *e) { if(selected_ && selected_->element_) { DynamicCast<Window>(selected_->element_)->SetImageRect(IntRect(48,0,64,16)); } selected_=e; if(e && e->element_) { DynamicCast<Window>(e->element_)->SetImageRect(IntRect(160,64,176,80)); } if(materialBuilder_ && selected_) { materialBuilder_->SetAlphaTexture(selected_->tex_); } }

AlphaBrushSelectorUI::AlphaBrushSelectorUI(Context *context); void AlphaBrushSelectorUI::Construct(TerrainMaterialBuilder *tmb); void AlphaBrushSelectorUI::PopulateList(); void AlphaBrushSelectorUI::HandleAlphaSelected(StringHash eventType, VariantMap &eventData);

db93703da261ef9d33dc737ce149a92d4a6cc2d05d9637677344def96c76fc71

synesissoftware

Pantheios

test/component/test.component.log.1/test.component.log.1.cpp

test_20

static void test_20() {}

int main(int argc, char** argv); static void test_01(); static void test_02(); static void test_03(); static void test_04(); static void test_05(); static void test_06(); static void test_07(); static void test_08(); static void test_09(); static void test_10(); static void test_11(); static void test_12(); static void test_13(); static void test_14(); static void test_15(); static void test_16(); static void test_17(); static void test_18(); static void test_19(); static void test_21(); static void test_22(); static void test_23(); static void test_24(); static void test_25(); static void test_26(); static void test_27(); static void test_28(); static void test_29();

a3a82a147d6b1452d3aa92174e72d61fec28d16a21cdf58cd304b4766e43b6f6

RaminNietzsche

POSFET

src/interface/timetableviewroomsform.cpp

TimetableViewRoomsForm::~TimetableViewRoomsForm

TimetableViewRoomsForm::~TimetableViewRoomsForm() { saveFETDialogGeometry(this); QSettings settings(COMPANY, PROGRAM); settings.setValue(this->metaObject()->className()+QString("/vertical-splitter-state"), verticalSplitter->saveState()); settings.setValue(this->metaObject()->className()+QString("/horizontal-splitter-state"), horizontalSplitter->saveState()); }

TimetableViewRoomsForm::TimetableViewRoomsForm(QWidget* parent); void TimetableViewRoomsForm::resizeRowsAfterShow(); void TimetableViewRoomsForm::roomChanged(const QString &roomName); void TimetableViewRoomsForm::updateRoomsTimetableTable(); void TimetableViewRoomsForm::resizeEvent(QResizeEvent* event); void TimetableViewRoomsForm::currentItemChanged(QTableWidgetItem* current, QTableWidgetItem* previous); void TimetableViewRoomsForm::detailActivity(QTableWidgetItem* item); void TimetableViewRoomsForm::lock(); void TimetableViewRoomsForm::lockTime(); void TimetableViewRoomsForm::lockSpace(); void TimetableViewRoomsForm::lock(bool lockTime, bool lockSpace); void TimetableViewRoomsForm::help();

3dfcfc5690f482d5018f66045d7bd568a011fddd5caf93c372c9a9ba51eda00f

Canpio

Paddle

paddle/api/Matrix.cpp

Matrix::isGpu

bool Matrix::isGpu() const { auto rawPtr = m->mat.get(); return dynamic_cast<paddle::GpuMatrix*>(rawPtr) != nullptr || dynamic_cast<paddle::GpuSparseMatrix*>(rawPtr) != nullptr; }

Matrix* Matrix::createByPaddleMatrixPtr(void* sharedPtr); Matrix* Matrix::createZero(size_t height, size_t width, bool useGpu); Matrix* Matrix::createGpuDenseFromNumpy(float* data, int dim1, int dim2); float Matrix::get(size_t x, size_t y); void Matrix::set(size_t x, size_t y, float val); bool Matrix::isSparse(); SparseValueType Matrix::getSparseValueType(); SparseFormatType Matrix::getSparseFormat(); IntArray Matrix::getSparseRowCols(size_t i); IntWithFloatArray Matrix::getSparseRowColsVal(size_t i); FloatArray Matrix::getData();

398892358840c89daf4e3c016c4ef83841a8573002aed6824dd3a14e66bd362e

pombredanne

FastPFor

src/simdunalignedbitpacking.cpp

__SIMD_fastpackwithoutmask22_32

static void __SIMD_fastpackwithoutmask22_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out) { const __m128i *in = reinterpret_cast<const __m128i*>(_in); __m128i OutReg; __m128i InReg = _mm_loadu_si128(in); OutReg = InReg; InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 22)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 12); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 12)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 2); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 2)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 24)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 14); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 14)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 4); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 4)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 26)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 16); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 16)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 6); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 6)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 28)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 18); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 18)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 8); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 8)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 30)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 20); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 20)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 10); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 10)); _mm_storeu_si128(out, OutReg); ++out; InReg = _mm_loadu_si128(++in); OutReg = InReg; InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 22)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 12); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 12)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 2); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 2)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 24)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 14); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 14)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 4); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 4)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 26)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 16); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 16)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 6); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 6)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 28)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 18); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 18)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 8); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 8)); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 30)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 20); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 20)); _mm_storeu_si128(out, OutReg); ++out; OutReg = _mm_srli_epi32(InReg, 22 - 10); InReg = _mm_loadu_si128(++in); OutReg = _mm_or_si128(OutReg, _mm_slli_epi32(InReg, 10)); _mm_storeu_si128(out, OutReg); }

static void SIMD_nullunpacker32(const __m128i * __restrict__ , uint32_t * __restrict__ out); static void __SIMD_fastpackwithoutmask1_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask2_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask3_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask5_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask6_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask7_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask9_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask10_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask11_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask12_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask13_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask14_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask15_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask17_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask18_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask19_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask20_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask21_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask23_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask24_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask25_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask26_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask27_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask28_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask29_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask30_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask31_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask32_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask4_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask8_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpackwithoutmask16_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack1_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack2_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack3_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack5_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack6_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack7_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack9_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack10_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack11_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack12_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack13_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack14_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack15_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack17_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack18_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack19_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack20_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack21_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack22_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack23_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack24_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack25_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack26_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack27_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack28_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack29_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack30_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack31_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack32_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack4_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack8_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastpack16_32(const uint32_t * __restrict__ _in, __m128i * __restrict__ out); static void __SIMD_fastunpack1_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack2_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack3_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack4_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack5_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack6_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack7_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack8_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack9_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack10_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack11_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack12_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack13_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack14_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack15_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack16_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack17_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack18_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack19_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack20_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack21_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack22_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack23_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack24_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack25_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack26_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack27_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack28_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack29_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack30_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack31_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); static void __SIMD_fastunpack32_32(const __m128i* __restrict__ in, uint32_t * __restrict__ _out); void usimdunpack(const __m128i * __restrict__ in, uint32_t * __restrict__ out, const uint32_t bit); void usimdpackwithoutmask(const uint32_t * __restrict__ in, __m128i * __restrict__ out, const uint32_t bit); void usimdpack(const uint32_t * __restrict__ in, __m128i * __restrict__ out, const uint32_t bit);

8e74cc07f67a8c3ab260af2b8e3c6462ae77738826b6c345d165a74ee89162ae

ZhangPeike

3D-Reconstruction-System

apps/umve/build/moc_glwidget.cpp

GLWidget::qt_metacall

int GLWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QGLWidget::qt_metacall(_c, _id, _a); if (_id < 0) return _id; if (_c == QMetaObject::InvokeMetaMethod) { if (_id < 3) qt_static_metacall(this, _c, _id, _a); _id -= 3; } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) { if (_id < 3) *reinterpret_cast<int*>(_a[0]) = -1; _id -= 3; } return _id; }

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

4aaf8434b43b5f046ae85f1b21fdb3333a8ccdbd7623c6da8f997c4ed040b0a3

Fat-Zer

FreeCAD_sf_master

src/Gui/Tree.cpp

DocumentItem::slotResetEdit

void DocumentItem::slotResetEdit(const Gui::ViewProviderDocumentObject& v) { auto tree = getTree(); FOREACH_ITEM_ALL(item) if(tree->editingItem) { if(item == tree->editingItem) { item->setData(0, Qt::BackgroundRole,QVariant()); break; } }else if(item->object() == &v) item->setData(0, Qt::BackgroundRole,QVariant()); END_FOREACH_ITEM tree->editingItem = 0; }

TreeParams::TreeParams(); void TreeParams::onSyncSelectionChanged(); void TreeParams::onCheckBoxesSelectionChanged(); void TreeParams::onDocumentModeChanged(); TreeParams *TreeParams::Instance(); void print(); TimingInfo(FC_DURATION &d); ~TimingInfo(); void stop(); void reset(); DocumentObjectData(DocumentItem *docItem, ViewProviderDocumentObject* vpd); const char *getTreeName(); void updateChildren(DocumentObjectDataPtr other); bool updateChildren(bool checkVisibility); void testStatus(bool resetStatus = false); void slotChangeIcon(); void slotChangeToolTip(const QString& tip); void slotChangeStatusTip(const QString& tip); void restore(Base::XMLReader &reader); TreeWidgetEditDelegate::TreeWidgetEditDelegate(QObject* parent); TreeWidget::~TreeWidget(); const char *TreeWidget::getTreeName(); void TreeWidget::selectAll(); bool TreeWidget::isObjectShowable(App::DocumentObject *obj); void TreeWidget::checkTopParent(App::DocumentObject *&obj, std::string &subname); void TreeWidget::resetItemSearch(); void TreeWidget::startItemSearch(QLineEdit *edit); void TreeWidget::itemSearch(const QString &text, bool select); Gui::Document *TreeWidget::selectedDocument(); void TreeWidget::updateStatus(bool delay); void TreeWidget::_updateStatus(bool delay); void TreeWidget::contextMenuEvent (QContextMenuEvent * e); void TreeWidget::hideEvent(QHideEvent *ev); void TreeWidget::showEvent(QShowEvent *ev); void TreeWidget::onCreateGroup(); void TreeWidget::onRelabelObject(); void TreeWidget::onStartEditing(); void TreeWidget::onFinishEditing(); void TreeWidget::onSkipRecompute(bool on); void TreeWidget::onAllowPartialRecompute(bool on); void TreeWidget::onMarkRecompute(); void TreeWidget::onRecomputeObject(); DocumentItem *TreeWidget::getDocumentItem(const Gui::Document *doc); void TreeWidget::selectAllInstances(const ViewProviderDocumentObject &vpd); TreeWidget *TreeWidget::instance(); std::vector<TreeWidget::SelInfo> TreeWidget::getSelection(App::Document *doc); void TreeWidget::selectAllLinks(App::DocumentObject *obj); void TreeWidget::onSearchObjects(); void TreeWidget::onActivateDocument(QAction* active); Qt::DropActions TreeWidget::supportedDropActions (); bool TreeWidget::event(QEvent *e); bool TreeWidget::eventFilter(QObject *, QEvent *ev); void TreeWidget::keyPressEvent(QKeyEvent *event); void TreeWidget::mouseDoubleClickEvent (QMouseEvent * event); void TreeWidget::startDragging(); void TreeWidget::startDrag(Qt::DropActions supportedActions); QMimeData * TreeWidget::mimeData (const QList<QTreeWidgetItem *> items); bool TreeWidget::dropMimeData(QTreeWidgetItem *parent, int index, const QMimeData *data, Qt::DropAction action); void TreeWidget::dragEnterEvent(QDragEnterEvent * event); void TreeWidget::dragLeaveEvent(QDragLeaveEvent * event); void TreeWidget::dragMoveEvent(QDragMoveEvent *event); void TreeWidget::dropEvent(QDropEvent *event); void TreeWidget::drawRow(QPainter *painter, const QStyleOptionViewItem &options, const QModelIndex &index); void TreeWidget::slotNewDocument(const Gui::Document& Doc, bool isMainDoc); void TreeWidget::slotStartOpenDocument(); void TreeWidget::slotFinishOpenDocument(); void TreeWidget::onReloadDoc(); void TreeWidget::onCloseDoc(); void TreeWidget::slotRenameDocument(const Gui::Document& Doc); void TreeWidget::slotChangedViewObject(const Gui::ViewProvider& vp, const App::Property &prop); void TreeWidget::slotTouchedObject(const App::DocumentObject &obj); void TreeWidget::slotShowHidden(const Gui::Document& Doc); void TreeWidget::slotRelabelDocument(const Gui::Document& Doc); void TreeWidget::slotActiveDocument(const Gui::Document& Doc); UpdateDisabler(QWidget &w, int &blocked); ~UpdateDisabler(); void TreeWidget::onUpdateStatus(void); void TreeWidget::onItemEntered(QTreeWidgetItem * item); void TreeWidget::leaveEvent(QEvent *); void TreeWidget::onPreSelectTimer(); void TreeWidget::onItemCollapsed(QTreeWidgetItem * item); void TreeWidget::onItemExpanded(QTreeWidgetItem * item); void TreeWidget::scrollItemToTop(); void TreeWidget::expandSelectedItems(TreeItemMode mode); void TreeWidget::setupText(); void TreeWidget::syncView(ViewProviderDocumentObject *vp); void TreeWidget::onShowHidden(); void TreeWidget::onHideInTree(); void TreeWidget::changeEvent(QEvent *e); void TreeWidget::onItemSelectionChanged (); static bool isSelectionCheckBoxesEnabled(); void TreeWidget::synchronizeSelectionCheckBoxes(); void TreeWidget::onItemChanged(QTreeWidgetItem *item, int column); void TreeWidget::onSelectTimer(); void TreeWidget::onSelectionChanged(const SelectionChanges& msg); TreePanel::TreePanel(const char *name, QWidget* parent); TreePanel::~TreePanel(); void TreePanel::accept(); bool TreePanel::eventFilter(QObject *obj, QEvent *ev); void TreePanel::showEditor(); void TreePanel::hideEditor(); void TreePanel::itemSearch(const QString &text); TreeDockWidget::TreeDockWidget(Gui::Document* pcDocument,QWidget *parent); TreeDockWidget::~TreeDockWidget(); void TreeWidget::selectLinkedObject(App::DocumentObject *linked); DocumentItem::DocumentItem(const Gui::Document* doc, QTreeWidgetItem * parent); DocumentItem::~DocumentItem(); TreeWidget *DocumentItem::getTree(); const char *DocumentItem::getTreeName(); void DocumentItem::slotInEdit(const Gui::ViewProviderDocumentObject& v); void DocumentItem::slotNewObject(const Gui::ViewProviderDocumentObject& obj); bool DocumentItem::createNewItem(const Gui::ViewProviderDocumentObject& obj, QTreeWidgetItem *parent, int index, DocumentObjectDataPtr data); ViewProviderDocumentObject *DocumentItem::getViewProvider(App::DocumentObject *obj); void TreeWidget::slotDeleteDocument(const Gui::Document& Doc); void TreeWidget::slotDeleteObject(const Gui::ViewProviderDocumentObject& view); void TreeWidget::_slotDeleteObject(const Gui::ViewProviderDocumentObject& view, DocumentItem *deletingDoc); bool DocumentItem::populateObject(App::DocumentObject *obj); void DocumentItem::populateItem(DocumentObjectItem *item, bool refresh, bool delay); int DocumentItem::findRootIndex(App::DocumentObject *childObj); void TreeWidget::slotChangeObject( const Gui::ViewProviderDocumentObject& view, const App::Property &prop); void TreeWidget::updateChildren(App::DocumentObject *obj, const std::set<DocumentObjectDataPtr> &dataSet, bool propOutput, bool force); void DocumentItem::slotHighlightObject (const Gui::ViewProviderDocumentObject& obj, const Gui::HighlightMode& high, bool set, const App::DocumentObject *parent, const char *subname); static unsigned int countExpandedItem(const QTreeWidgetItem *item); unsigned int DocumentItem::getMemSize(void); static void saveExpandedItem(Base::Writer &writer, const QTreeWidgetItem *item); void DocumentItem::Save (Base::Writer &writer); void DocumentItem::Restore(Base::XMLReader &reader); void DocumentItem::restoreItemExpansion(const ExpandInfoPtr &info, DocumentObjectItem *item); void DocumentItem::slotExpandObject (const Gui::ViewProviderDocumentObject& obj, const Gui::TreeItemMode& mode, const App::DocumentObject *parent, const char *subname); void DocumentItem::slotScrollToObject(const Gui::ViewProviderDocumentObject& obj); void DocumentItem::slotRecomputedObject(const App::DocumentObject &obj); void DocumentItem::slotRecomputed(const App::Document &, const std::vector<App::DocumentObject*> &objs); Gui::Document* DocumentItem::document(); void DocumentItem::testStatus(void); void DocumentItem::setData (int column, int role, const QVariant & value); void DocumentItem::clearSelection(DocumentObjectItem *exclude); void DocumentItem::updateSelection(QTreeWidgetItem *ti, bool unselect); void DocumentItem::updateItemSelection(DocumentObjectItem *item); App::DocumentObject *DocumentItem::getTopParent(App::DocumentObject *obj, std::string &subname); DocumentObjectItem *DocumentItem::findItemByObject( bool sync, App::DocumentObject *obj, const char *subname, bool select); DocumentObjectItem *DocumentItem::findItem( bool sync, DocumentObjectItem *item, const char *subname, bool select); void DocumentItem::selectItems(SelectionReason reason); void DocumentItem::populateParents(const ViewProvider *vp, ViewParentMap &parentMap); void DocumentItem::selectAllInstances(const ViewProviderDocumentObject &vpd); bool DocumentItem::showHidden(); void DocumentItem::setShowHidden(bool show); bool DocumentItem::showItem(DocumentObjectItem *item, bool select, bool force); void DocumentItem::updateItemsVisibility(QTreeWidgetItem *item, bool show); void DocumentItem::updateSelection(); DocumentObjectItem::DocumentObjectItem(DocumentItem *ownerDocItem, DocumentObjectDataPtr data); DocumentObjectItem::~DocumentObjectItem(); void DocumentObjectItem::restoreBackground(); void DocumentObjectItem::setHighlight(bool set, Gui::HighlightMode high); const char *DocumentObjectItem::getTreeName(); Gui::ViewProviderDocumentObject* DocumentObjectItem::object(); void DocumentObjectItem::testStatus(bool resetStatus); void DocumentObjectItem::testStatus(bool resetStatus, QIcon &icon1, QIcon &icon2); void DocumentObjectItem::displayStatusInfo(); void DocumentObjectItem::setExpandedStatus(bool on); void DocumentObjectItem::setData (int column, int role, const QVariant & value); bool DocumentObjectItem::isChildOfItem(DocumentObjectItem* item); bool DocumentObjectItem::requiredAtRoot(bool excludeSelf); bool DocumentObjectItem::isLink(); bool DocumentObjectItem::isLinkFinal(); bool DocumentObjectItem::isParentLink(); int DocumentObjectItem::isGroup(); bool DocumentItem::isObjectShowable(App::DocumentObject *obj); int DocumentObjectItem::isParentGroup(); DocumentObjectItem *DocumentObjectItem::getParentItem(); const char *DocumentObjectItem::getName(); int DocumentObjectItem::getSubName(std::ostringstream &str, App::DocumentObject *&topParent); App::DocumentObject *DocumentObjectItem::getFullSubName( std::ostringstream &str, DocumentObjectItem *parent); void DocumentObjectItem::setCheckState(bool checked); DocumentItem *DocumentObjectItem::getParentDocument(); DocumentItem *DocumentObjectItem::getOwnerDocument(); TreeWidget *DocumentObjectItem::getTree();

869ddfd43375769dff8f84555bc4e2822a18acfddae42581c8e3c10cf9395af4

kgudger

PuzDuko

qqwing.cpp

SudokuBoard::rollbackRound

void SudokuBoard::rollbackRound(int round){ if (logHistory || recordHistory) addHistoryItem(new LogItem(round, LogItem::ROLLBACK)); {for (int i=0; i<BOARD_SIZE; i++){ if (solutionRound[i] == round){ solutionRound[i] = 0; solution[i] = 0; } }} {for (int i=0; i<POSSIBILITY_SIZE; i++){ if (possibilities[i] == round){ possibilities[i] = 0; } }} while(solveInstructions->size() > 0 && solveInstructions->back()->getRound() == round){ solveInstructions->pop_back(); } }

int main(int argc, char *argv[]); void printVersion(); void printAbout(); void printHelp(char* programName); SudokuBoard::SudokuBoard(); SudokuBoard::~SudokuBoard(); int SudokuBoard::getGivenCount(); bool SudokuBoard::setPuzzle(int* initPuzzle); void SudokuBoard::setHighLights(bool printHighLights); bool SudokuBoard::reset(); SudokuBoard::Difficulty SudokuBoard::getDifficulty(); string SudokuBoard::getDifficultyAsString(); int SudokuBoard::getSingleCount(); int SudokuBoard::getHiddenSingleCount(); int SudokuBoard::getNakedPairCount(); int SudokuBoard::getHiddenPairCount(); int SudokuBoard::getPointingPairTripleCount(); int SudokuBoard::getBoxLineReductionCount(); int SudokuBoard::getGuessCount(); int SudokuBoard::getBacktrackCount(); void SudokuBoard::markRandomPossibility(int round); void SudokuBoard::shuffleRandomArrays(); void SudokuBoard::clearPuzzle(); bool SudokuBoard::generatePuzzle(); void SudokuBoard::rollbackNonGuesses(); void SudokuBoard::setPrintStyle(PrintStyle ps); void SudokuBoard::findHighLights(); void SudokuBoard::moveRow(int row, int secondrowpointer); void SudokuBoard::moveCol(int col, int secondcolpointer); void SudokuBoard::setPhrase(string* inphraseString); void SudokuBoard::setRecordHistory(bool recHistory); void SudokuBoard::setLogHistory(bool logHist); void SudokuBoard::addHistoryItem(LogItem* l); void SudokuBoard::printHistory(vector<LogItem*>* v); void SudokuBoard::printSolveInstructions(); void SudokuBoard::printSolveHistory(); bool SudokuBoard::solve(); bool SudokuBoard::solve(int round); int SudokuBoard::countSolutions(); int SudokuBoard::countSolutions(int round, bool limitToTwo); bool SudokuBoard::isSolved(); bool SudokuBoard::isImpossible(); int SudokuBoard::findPositionWithFewestPossibilities(); bool SudokuBoard::guess(int round, int guessNumber); bool SudokuBoard::singleSolveMove(int round); bool SudokuBoard::colBoxReduction(int round); bool SudokuBoard::rowBoxReduction(int round); bool SudokuBoard::pointingRowReduction(int round); bool SudokuBoard::pointingColumnReduction(int round); int SudokuBoard::countPossibilities(int position); bool SudokuBoard::arePossibilitiesSame(int position1, int position2); bool SudokuBoard::removePossibilitiesInOneFromTwo(int position1, int position2, int round); bool SudokuBoard::hiddenPairInColumn(int round); bool SudokuBoard::hiddenPairInSection(int round); bool SudokuBoard::hiddenPairInRow(int round); bool SudokuBoard::handleNakedPairs(int round); bool SudokuBoard::onlyValueInRow(int round); bool SudokuBoard::onlyValueInColumn(int round); bool SudokuBoard::onlyValueInSection(int round); bool SudokuBoard::onlyPossibilityForCell(int round); void SudokuBoard::mark(int position, int round, int value); void SudokuBoard::printPossibilities(); void SudokuBoard::print(int* sudoku); void SudokuBoard::printPuzzle(); void SudokuBoard::printHighlights(); void SudokuBoard::printSolution(); void SudokuBoard::printPhrase(); LogItem::LogItem(int r, LogType t); LogItem::LogItem(int r, LogType t, int v, int p); void LogItem::init(int r, LogType t, int v, int p); LogItem::~LogItem(); int LogItem::getRound(); LogItem::LogType LogItem::getType(); void LogItem::print(); int getLogCount(vector<LogItem*>* v, LogItem::LogType type); long getMicroseconds(); void shuffleArray(int* array, int size); bool readPuzzleFromStdIn(int* puzzle); static inline int cellToColumn(int cell); static inline int cellToRow(int cell); static inline int cellToSection(int cell); static inline int cellToSectionStartCell(int cell); static inline int rowToFirstCell(int row); static inline int columnToFirstCell(int column); static inline int sectionToFirstCell(int section); static inline int getPossibilityIndex(int valueIndex, int cell); static inline int rowColumnToCell(int row, int column); static inline int sectionToCell(int section, int offset);

51f6ec9335853092f4dd432bbd0ed0b47e32a29c18968b669709b0104058e1db

jkriege2

JKQtPlotter

lib/jkqtplotter/graphs/jkqtpevaluatedfunctionbase.cpp

JKQTPEvaluatedFunctionGraphBase::setMinPixelPerSample

void JKQTPEvaluatedFunctionGraphBase::setMinPixelPerSample(double __value) { this->minPixelPerSample = __value; }

JKQTPEvaluatedFunctionGraphBase::JKQTPEvaluatedFunctionGraphBase(JKQTBasePlotter* parent); JKQTPEvaluatedFunctionGraphBase::JKQTPEvaluatedFunctionGraphBase(JKQTPlotter* parent); JKQTPEvaluatedFunctionGraphBase::~JKQTPEvaluatedFunctionGraphBase(); void JKQTPEvaluatedFunctionGraphBase::drawSamplePoints(JKQTPEnhancedPainter& painter, QColor graphColor); void JKQTPEvaluatedFunctionGraphBase::setMinSamples(const unsigned int &__value); unsigned int JKQTPEvaluatedFunctionGraphBase::getMinSamples(); void JKQTPEvaluatedFunctionGraphBase::setMaxRefinementDegree(const unsigned int &__value); unsigned int JKQTPEvaluatedFunctionGraphBase::getMaxRefinementDegree(); void JKQTPEvaluatedFunctionGraphBase::setSlopeTolerance(double __value); double JKQTPEvaluatedFunctionGraphBase::getSlopeTolerance(); double JKQTPEvaluatedFunctionGraphBase::getMinPixelPerSample(); void JKQTPEvaluatedFunctionGraphBase::setDataCleanupMaxAllowedAngleDegree(double __value); double JKQTPEvaluatedFunctionGraphBase::getDataCleanupMaxAllowedAngleDegree(); void JKQTPEvaluatedFunctionGraphBase::setDisplaySamplePoints(bool __value); void JKQTPEvaluatedFunctionGraphBase::createPlotData(bool collectParams); bool JKQTPEvaluatedFunctionGraphBase::getDisplaySamplePoints(); bool JKQTPEvaluatedFunctionGraphBase::getXMinMax(double &minx, double &maxx, double &smallestGreaterZero); bool JKQTPEvaluatedFunctionGraphBase::getYMinMax(double &miny, double &maxy, double &smallestGreaterZero); void JKQTPEvaluatedFunctionGraphBase::collectParameters(); void JKQTPEvaluatedFunctionGraphBase::setParams(const QVector<double> &params); void JKQTPEvaluatedFunctionGraphBase::setCopiedParams(const double *params, int N); void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1); void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2); void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3); void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3, double p4); void JKQTPEvaluatedFunctionGraphBase::setParamsV(double p1, double p2, double p3, double p4, double p5); void JKQTPEvaluatedFunctionGraphBase::setParameterColumn(int __value); int JKQTPEvaluatedFunctionGraphBase::getParameterColumn(); void JKQTPEvaluatedFunctionGraphBase::setParameterColumn(size_t __value); const QVector<double>& JKQTPEvaluatedFunctionGraphBase::getInternalParams(); QVector<double> &JKQTPEvaluatedFunctionGraphBase::getInternalParams(); bool JKQTPEvaluatedFunctionGraphBase::usesColumn(int c); JKQTPEvaluatedFunctionGraphBase::PlotFunctorSpec::PlotFunctorSpec(); bool JKQTPEvaluatedFunctionGraphBase::PlotFunctorSpec::isValid(); JKQTPEvaluatedFunctionWithErrorsGraphBase::JKQTPEvaluatedFunctionWithErrorsGraphBase(JKQTBasePlotter *parent); JKQTPEvaluatedFunctionWithErrorsGraphBase::JKQTPEvaluatedFunctionWithErrorsGraphBase(JKQTPlotter *parent); JKQTPEvaluatedFunctionWithErrorsGraphBase::~JKQTPEvaluatedFunctionWithErrorsGraphBase(); const QVector<double>& JKQTPEvaluatedFunctionWithErrorsGraphBase::getInternalErrorParams(); QVector<double>& JKQTPEvaluatedFunctionWithErrorsGraphBase::getInternalErrorParams(); bool JKQTPEvaluatedFunctionWithErrorsGraphBase::usesColumn(int c); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParams(const QVector<double> &errorParams); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParameterColumn(int __value); int JKQTPEvaluatedFunctionWithErrorsGraphBase::getErrorParameterColumn(); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParameterColumn(size_t __value); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3, double p4); void JKQTPEvaluatedFunctionWithErrorsGraphBase::setErrorParamsV(double p1, double p2, double p3, double p4, double p5); void JKQTPEvaluatedFunctionWithErrorsGraphBase::collectParameters();

624d10f4277643f81b9c9efc06ecb94d3d222dc4f9631405d8635a3a08f82f75

SelfieSticks

TowerBloCF

The Project/Il2CppOutputProject/Source/il2cppOutput/Il2CppCompilerCalculateTypeValues_25Table.cpp

set_ignoreWhitespace_9

nline void set_ignoreWhitespace_9(bool value) { ___ignoreWhitespace_9 = value; }

nline void set_localName_0(String_t* value); nline void set_namespaceUri_1(String_t* value); nline void set_prefix_2(String_t* value); nline void set_baseUri_3(String_t* value); nline void set_pageParent_4(XPathNodeU5BU5D_t47339301* value); nline void set_pageSibling_5(XPathNodeU5BU5D_t47339301* value); nline void set_pageSimilar_6(XPathNodeU5BU5D_t47339301* value); nline void set_doc_7(XPathDocument_t1673143697 * value); nline void set_lineNumBase_8(int32_t value); nline void set_linePosBase_9(int32_t value); nline void set_hashCode_10(int32_t value); nline void set_localNameHash_11(int32_t value); nline void set_pageInfo_12(XPathNodePageInfo_t2343388010 * value); nline void set_pageNum_0(int32_t value); nline void set_nodeCount_1(int32_t value); nline void set_pageNext_2(XPathNodeU5BU5D_t47339301* value); nline void set_scanner_0(XPathScanner_t3283201025 * value); nline void set_parseDepth_1(int32_t value); nline void set_temparray1_2(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray2_3(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray3_4(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray4_5(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray5_6(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray6_7(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray7_8(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray8_9(XPathResultTypeU5BU5D_t1515527577* value); nline void set_temparray9_10(XPathResultTypeU5BU5D_t1515527577* value); nline void set_functionTable_11(Hashtable_t1853889766 * value); nline void set_AxesTable_12(Hashtable_t1853889766 * value); nline void set__objects_0(ArrayList_t2718874744 * value); nline void set_isKeys_1(bool value); nline void set_data_0(ArrayList_t2718874744 * value); nline void set_contents_0(Hashtable_t1853889766 * value); nline void set_leftOverBytes_0(ByteU5BU5D_t4116647657* value); nline void set_leftOverBytesCount_1(int32_t value); nline void set_charsLine_2(CharU5BU5D_t3528271667* value); nline void set__targetsAtLeast_Desktop_V4_5_2_0(bool value); nline void set_MASK_0101010101010101_0(uint32_t value); nline void set_MASK_0011001100110011_1(uint32_t value); nline void set_MASK_0000111100001111_2(uint32_t value); nline void set_MASK_0000000011111111_3(uint32_t value); nline void set_MASK_1111111111111111_4(uint32_t value); nline void set_hashCodeRandomizer_1(int32_t value); nline void set_hashCodeDelegate_0(HashCodeOfStringDelegate_t1614268366 * value); nline void set_nsdecls_0(NamespaceDeclarationU5BU5D_t3609802718* value); nline void set_lastDecl_1(int32_t value); nline void set_nameTable_2(XmlNameTable_t71772148 * value); nline void set_scopeId_3(int32_t value); nline void set_hashTable_4(Dictionary_2_t2736202052 * value); nline void set_useHashtable_5(bool value); nline void set_xml_6(String_t* value); nline void set_xmlNs_7(String_t* value); nline void set_IsTextualNodeBitmap_0(uint32_t value); nline void set_CanReadContentAsBitmap_1(uint32_t value); nline void set_HasValueBitmap_2(uint32_t value); nline void set_s_instance_0(RuntimeObject* value); nline void set_reader_0(XmlTextReaderImpl_t178060594 * value); nline void set_writeNodeBuffer_0(CharU5BU5D_t3528271667* value); nline void set_info_0(XPathNodeInfoAtom_t1760358141 * value); nline void set_idxSibling_1(uint16_t value); nline void set_idxParent_2(uint16_t value); nline void set_idxSimilar_3(uint16_t value); nline void set_posOffset_4(uint16_t value); nline void set_props_5(uint32_t value); nline void set_value_6(String_t* value); nline void set_page_0(XPathNodeU5BU5D_t47339301* value); nline void set_idx_1(int32_t value); nline void set_input_0(AstNode_t2514041814 * value); nline void set_condition_1(AstNode_t2514041814 * value); nline void set_groupNode_0(AstNode_t2514041814 * value); nline void set_localname_0(String_t* value); nline void set_prefix_1(String_t* value); nline void set_enumSeperatorCharArray_0(CharU5BU5D_t3528271667* value); nline void set_m_value_0(int32_t value); nline void set_m_value_0(int64_t value); nline void set_m_value_0(void* value); nline void set_Zero_1(intptr_t value); nline void set_value_0(bool value); nline void set_has_value_1(bool value); nline void set_buffer_0(ByteU5BU5D_t4116647657* value); nline void set_curIndex_1(int32_t value); nline void set_endIndex_2(int32_t value); nline void set_hasHalfByteCached_3(bool value); nline void set_cachedHalfByte_4(uint8_t value); nline void set_lineNo_0(int32_t value); nline void set_linePos_1(int32_t value); nline void set_comparer_0(XPathNavigatorKeyComparer_t2518900029 * value); nline void set_NodeTypeLetter_1(CharU5BU5D_t3528271667* value); nline void set_UniqueIdTbl_2(CharU5BU5D_t3528271667* value); nline void set_ContentKindMasks_3(Int32U5BU5D_t385246372* value); nline void set_charProperties_2(ByteU5BU5D_t4116647657* value); nline void set_s_Lock_0(RuntimeObject * value); nline void set_s_CharProperties_1(ByteU5BU5D_t4116647657* value); nline void set_impl_3(XmlTextReaderImpl_t178060594 * value); nline void set_chars_0(CharU5BU5D_t3528271667* value); nline void set_charPos_1(int32_t value); nline void set_charsUsed_2(int32_t value); nline void set_encoding_3(Encoding_t1523322056 * value); nline void set_appendMode_4(bool value); nline void set_stream_5(Stream_t1273022909 * value); nline void set_decoder_6(Decoder_t2204182725 * value); nline void set_bytes_7(ByteU5BU5D_t4116647657* value); nline void set_bytePos_8(int32_t value); nline void set_bytesUsed_9(int32_t value); nline void set_textReader_10(TextReader_t283511965 * value); nline void set_lineNo_11(int32_t value); nline void set_lineStartPos_12(int32_t value); nline void set_baseUriStr_13(String_t* value); nline void set_baseUri_14(Uri_t100236324 * value); nline void set_isEof_15(bool value); nline void set_isStreamEof_16(bool value); nline void set_entity_17(RuntimeObject* value); nline void set_entityId_18(int32_t value); nline void set_eolNormalized_19(bool value); nline void set_entityResolvedManually_20(bool value); nline void set_xmlTextEncoder_3(XmlTextEncoder_t1632274355 * value); nline void set_U30283A6AF88802AB45989B29549915BEA0F6CD515_0(__StaticArrayInitTypeSizeU3D14_t3517563373 value); nline void set_U303F4297FCC30D0FD5E420E5D26E7FA711167C7EF_1(int64_t value); nline void set_U31A39764B112685485A5BA7B2880D878B858C1A7A_2(__StaticArrayInitTypeSizeU3D9_t3218278900 value); nline void set_U31A84029C80CB5518379F199F53FF08A7B764F8FD_3(__StaticArrayInitTypeSizeU3D3_t3217885684 value); nline void set_U33BE77BF818331C2D8400FFFFF9FADD3F16AD89AC_4(__StaticArrayInitTypeSizeU3D12_t2710994318 value); nline void set_U359F5BD34B6C013DEACC784F69C67E95150033A84_5(__StaticArrayInitTypeSizeU3D32_t2711125391 value); nline void set_U35BC3486B05BA8CF4689C7BDB198B3F477BB4E20C_6(__StaticArrayInitTypeSizeU3D6_t3217689075 value); nline void set_U36D49C9D487D7AD3491ECE08732D68A593CC2038D_7(__StaticArrayInitTypeSizeU3D9_t3218278900 value); nline void set_U36F3AD3DC3AF8047587C4C9D696EB68A01FEF796E_8(__StaticArrayInitTypeSizeU3D128_t531529102 value); nline void set_U38E0EF3D67A3EB1863224EE3CACB424BC2F8CFBA3_9(__StaticArrayInitTypeSizeU3D44_t3517366764 value); nline void set_U398A44A6F8606AE6F23FE230286C1D6FBCC407226_10(int64_t value); nline void set_ADDB8526F472C1C6D36DBD5A6E509D973CC34C92_11(__StaticArrayInitTypeSizeU3D12_t2710994318 value); nline void set_C02C28AFEBE998F767E4AF43E3BE8F5E9FA11536_12(__StaticArrayInitTypeSizeU3D32_t2711125391 value); nline void set_CCEEADA43268372341F81AE0C9208C6856441C04_13(__StaticArrayInitTypeSizeU3D128_t531529102 value); nline void set_E5BC1BAFADE1862DD6E0B9FB632BFAA6C3873A78_14(int64_t value); nline void set_EC5842B3154E1AF94500B57220EB9F684BCCC42A_15(__StaticArrayInitTypeSizeU3D32_t2711125391 value); nline void set_EEAFE8C6E1AB017237567305EE925C976CDB6458_16(__StaticArrayInitTypeSizeU3D256_t1757367633 value); nline void set_pageCurrent_4(XPathNodeU5BU5D_t47339301* value); nline void set_pageParent_5(XPathNodeU5BU5D_t47339301* value); nline void set_idxCurrent_6(int32_t value); nline void set_idxParent_7(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_method_ptr_0(Il2CppMethodPointer value); nline void set_invoke_impl_1(intptr_t value); nline void set_m_target_2(RuntimeObject * value); nline void set_method_3(intptr_t value); nline void set_delegate_trampoline_4(intptr_t value); nline void set_extra_arg_5(intptr_t value); nline void set_method_code_6(intptr_t value); nline void set_method_info_7(MethodInfo_t * value); nline void set_original_method_info_8(MethodInfo_t * value); nline void set_data_9(DelegateData_t1677132599 * value); nline void set_method_is_virtual_10(bool value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_textWriter_0(TextWriter_t3478189236 * value); nline void set_inAttribute_1(bool value); nline void set_quoteChar_2(Il2CppChar value); nline void set_attrValue_3(StringBuilder_t * value); nline void set_cacheAttrValue_4(bool value); nline void set_xmlCharType_5(XmlCharType_t2277243275 value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_value___2(int32_t value); nline void set_axisType_0(int32_t value); nline void set_input_1(AstNode_t2514041814 * value); nline void set_prefix_2(String_t* value); nline void set_name_3(String_t* value); nline void set_nodeType_4(int32_t value); nline void set_abbrAxis_5(bool value); nline void set_urn_6(String_t* value); nline void set_functionType_0(int32_t value); nline void set_argumentList_1(ArrayList_t2718874744 * value); nline void set_name_2(String_t* value); nline void set_prefix_3(String_t* value); nline void set_ReturnTypes_4(XPathResultTypeU5BU5D_t1515527577* value); nline void set_type_0(int32_t value); nline void set_val_1(RuntimeObject * value); nline void set_opType_1(int32_t value); nline void set_opnd1_2(AstNode_t2514041814 * value); nline void set_opnd2_3(AstNode_t2514041814 * value); nline void set_invertOp_0(OpU5BU5D_t2837398892* value); nline void set_ftype_0(int32_t value); nline void set_minargs_1(int32_t value); nline void set_maxargs_2(int32_t value); nline void set_argTypes_3(XPathResultTypeU5BU5D_t1515527577* value); nline void set_xpathExpr_0(String_t* value); nline void set_xpathExprIndex_1(int32_t value); nline void set_kind_2(int32_t value); nline void set_currentChar_3(Il2CppChar value); nline void set_name_4(String_t* value); nline void set_prefix_5(String_t* value); nline void set_stringValue_6(String_t* value); nline void set_numberValue_7(double value); nline void set_canBeFunction_8(bool value); nline void set_xmlCharType_9(XmlCharType_t2277243275 value); nline void set_delegates_11(DelegateU5BU5D_t1703627840* value); nline void set_reader_0(XmlReader_t3121518892 * value); nline void set_state_1(int32_t value); nline void set_valueOffset_2(int32_t value); nline void set_isEnd_3(bool value); nline void set__nt_0(XmlNameTable_t71772148 * value); nline void set__nsMgr_1(XmlNamespaceManager_t418790500 * value); nline void set__docTypeName_2(String_t* value); nline void set__pubId_3(String_t* value); nline void set__sysId_4(String_t* value); nline void set__internalSubset_5(String_t* value); nline void set__xmlLang_6(String_t* value); nline void set__xmlSpace_7(int32_t value); nline void set__baseURI_8(String_t* value); nline void set__encoding_9(Encoding_t1523322056 * value); nline void set_useAsync_0(bool value); nline void set_nameTable_1(XmlNameTable_t71772148 * value); nline void set_xmlResolver_2(XmlResolver_t626023767 * value); nline void set_lineNumberOffset_3(int32_t value); nline void set_linePositionOffset_4(int32_t value); nline void set_conformanceLevel_5(int32_t value); nline void set_checkCharacters_6(bool value); nline void set_maxCharactersInDocument_7(int64_t value); nline void set_maxCharactersFromEntities_8(int64_t value); nline void set_ignorePIs_10(bool value); nline void set_ignoreComments_11(bool value); nline void set_dtdProcessing_12(int32_t value); nline void set_validationType_13(int32_t value); nline void set_validationFlags_14(int32_t value); nline void set_schemas_15(XmlSchemaSet_t266093086 * value); nline void set_closeInput_16(bool value); nline void set_isReadOnly_17(bool value); nline void set_U3CIsXmlResolverSetU3Ek__BackingField_18(bool value); nline void set_s_enableLegacyXmlSettings_19(Nullable_1_t1819850047 value); nline void set_laterInitParam_3(LaterInitParam_t1449395818 * value); nline void set_xmlCharType_4(XmlCharType_t2277243275 value); nline void set_ps_5(ParsingState_t1780334922 value); nline void set_parsingFunction_6(int32_t value); nline void set_nextParsingFunction_7(int32_t value); nline void set_nextNextParsingFunction_8(int32_t value); nline void set_nodes_9(NodeDataU5BU5D_t1309219640* value); nline void set_curNode_10(NodeData_t1817330133 * value); nline void set_index_11(int32_t value); nline void set_curAttrIndex_12(int32_t value); nline void set_attrCount_13(int32_t value); nline void set_attrHashtable_14(int32_t value); nline void set_attrDuplWalkCount_15(int32_t value); nline void set_attrNeedNamespaceLookup_16(bool value); nline void set_fullAttrCleanup_17(bool value); nline void set_attrDuplSortingArray_18(NodeDataU5BU5D_t1309219640* value); nline void set_nameTable_19(XmlNameTable_t71772148 * value); nline void set_nameTableFromSettings_20(bool value); nline void set_xmlResolver_21(XmlResolver_t626023767 * value); nline void set_url_22(String_t* value); nline void set_normalize_23(bool value); nline void set_supportNamespaces_24(bool value); nline void set_whitespaceHandling_25(int32_t value); nline void set_dtdProcessing_26(int32_t value); nline void set_entityHandling_27(int32_t value); nline void set_ignorePIs_28(bool value); nline void set_ignoreComments_29(bool value); nline void set_checkCharacters_30(bool value); nline void set_lineNumberOffset_31(int32_t value); nline void set_linePositionOffset_32(int32_t value); nline void set_closeInput_33(bool value); nline void set_maxCharactersInDocument_34(int64_t value); nline void set_maxCharactersFromEntities_35(int64_t value); nline void set_v1Compat_36(bool value); nline void set_namespaceManager_37(XmlNamespaceManager_t418790500 * value); nline void set_lastPrefix_38(String_t* value); nline void set_xmlContext_39(XmlContext_t1618903103 * value); nline void set_parsingStatesStack_40(ParsingStateU5BU5D_t1980313167* value); nline void set_parsingStatesStackTop_41(int32_t value); nline void set_reportedBaseUri_42(String_t* value); nline void set_reportedEncoding_43(Encoding_t1523322056 * value); nline void set_dtdInfo_44(RuntimeObject* value); nline void set_fragmentType_45(int32_t value); nline void set_fragmentParserContext_46(XmlParserContext_t2544895291 * value); nline void set_fragment_47(bool value); nline void set_incReadDecoder_48(IncrementalReadDecoder_t3011954239 * value); nline void set_incReadState_49(int32_t value); nline void set_incReadLineInfo_50(LineInfo_t3266778363 value); nline void set_incReadDepth_51(int32_t value); nline void set_incReadLeftStartPos_52(int32_t value); nline void set_incReadLeftEndPos_53(int32_t value); nline void set_attributeValueBaseEntityId_54(int32_t value); nline void set_emptyEntityInAttributeResolved_55(bool value); nline void set_validationEventHandling_56(RuntimeObject* value); nline void set_onDefaultAttributeUse_57(OnDefaultAttributeUseDelegate_t2911570364 * value); nline void set_validatingReaderCompatFlag_58(bool value); nline void set_addDefaultAttributesAndNormalize_59(bool value); nline void set_stringBuilder_60(StringBuilder_t * value); nline void set_rootElementParsed_61(bool value); nline void set_standalone_62(bool value); nline void set_nextEntityId_63(int32_t value); nline void set_parsingMode_64(int32_t value); nline void set_readState_65(int32_t value); nline void set_lastEntity_66(RuntimeObject* value); nline void set_afterResetState_67(bool value); nline void set_documentStartBytePos_68(int32_t value); nline void set_readValueOffset_69(int32_t value); nline void set_charactersInDocument_70(int64_t value); nline void set_charactersFromEntities_71(int64_t value); nline void set_currentEntities_72(Dictionary_2_t1740447880 * value); nline void set_disableUndeclaredEntityCheck_73(bool value); nline void set_outerReader_74(XmlReader_t3121518892 * value); nline void set_xmlResolverIsSet_75(bool value); nline void set_Xml_76(String_t* value); nline void set_XmlNs_77(String_t* value); nline void set_parseText_dummyTask_78(Task_1_t1685771062 * value); nline void set_useAsync_0(bool value); nline void set_inputStream_1(Stream_t1273022909 * value); nline void set_inputBytes_2(ByteU5BU5D_t4116647657* value); nline void set_inputByteCount_3(int32_t value); nline void set_inputbaseUri_4(Uri_t100236324 * value); nline void set_inputUriStr_5(String_t* value); nline void set_inputUriResolver_6(XmlResolver_t626023767 * value); nline void set_inputContext_7(XmlParserContext_t2544895291 * value); nline void set_inputTextReader_8(TextReader_t283511965 * value); nline void set_initType_9(int32_t value); nline void set_type_1(int32_t value); nline void set_localName_2(String_t* value); nline void set_prefix_3(String_t* value); nline void set_ns_4(String_t* value); nline void set_nameWPrefix_5(String_t* value); nline void set_value_6(String_t* value); nline void set_chars_7(CharU5BU5D_t3528271667* value); nline void set_valueStartPos_8(int32_t value); nline void set_valueLength_9(int32_t value); nline void set_lineInfo_10(LineInfo_t3266778363 value); nline void set_lineInfo2_11(LineInfo_t3266778363 value); nline void set_quoteChar_12(Il2CppChar value); nline void set_depth_13(int32_t value); nline void set_isEmptyOrDefault_14(bool value); nline void set_entityId_15(int32_t value); nline void set_xmlContextPushed_16(bool value); nline void set_nextAttrValueChunk_17(NodeData_t1817330133 * value); nline void set_schemaType_18(RuntimeObject * value); nline void set_typedValue_19(RuntimeObject * value); nline void set_s_None_0(NodeData_t1817330133 * value); nline void set_xmlSpace_0(int32_t value); nline void set_xmlLang_1(String_t* value); nline void set_defaultNamespace_2(String_t* value); nline void set_previousContext_3(XmlContext_t1618903103 * value); nline void set_textWriter_1(TextWriter_t3478189236 * value); nline void set_xmlEncoder_2(XmlTextEncoder_t1632274355 * value); nline void set_encoding_3(Encoding_t1523322056 * value); nline void set_formatting_4(int32_t value); nline void set_indented_5(bool value); nline void set_indentation_6(int32_t value); nline void set_indentChar_7(Il2CppChar value); nline void set_stack_8(TagInfoU5BU5D_t2840723532* value); nline void set_top_9(int32_t value); nline void set_stateTable_10(StateU5BU5D_t428546178* value); nline void set_currentState_11(int32_t value); nline void set_lastToken_12(int32_t value); nline void set_base64Encoder_13(XmlTextWriterBase64Encoder_t4259465041 * value); nline void set_quoteChar_14(Il2CppChar value); nline void set_curQuoteChar_15(Il2CppChar value); nline void set_namespaces_16(bool value); nline void set_specialAttr_17(int32_t value); nline void set_prefixForXmlNs_18(String_t* value); nline void set_flush_19(bool value); nline void set_nsStack_20(NamespaceU5BU5D_t4259279085* value); nline void set_nsTop_21(int32_t value); nline void set_nsHashtable_22(Dictionary_2_t2736202052 * value); nline void set_useNsHashtable_23(bool value); nline void set_xmlCharType_24(XmlCharType_t2277243275 value); nline void set_stateName_25(StringU5BU5D_t1281789340* value); nline void set_tokenName_26(StringU5BU5D_t1281789340* value); nline void set_stateTableDefault_27(StateU5BU5D_t428546178* value); nline void set_stateTableDocument_28(StateU5BU5D_t428546178* value);

1a1f1f5e899800d35c66013094a9fa11a07ca5c9fa2f3c22a0359495135dfc55

correa

domoticz

hardware/I2C.cpp

I2C::bmp_Read_BME_SensorDetails

void I2C::bmp_Read_BME_SensorDetails() { float temperature, pressure; int humidity; #ifndef HAVE_LINUX_I2C #ifndef _DEBUG _log.Log(LOG_ERROR, "%s: I2C is unsupported on this architecture!...", szI2CTypeNames[m_dev_type]); return; #else _log.Log(LOG_ERROR, "%s: I2C is unsupported on this architecture!... Debug: just adding a value", szI2CTypeNames[m_dev_type]); #endif temperature = 21.3f; pressure = 1021.22f; humidity = 70; #else int fd = i2c_Open(m_ActI2CBus.c_str()); if (fd < 0) { _log.Log(LOG_ERROR, "%s: Error opening device!...", szI2CTypeNames[m_dev_type]); return; } if (!readBME280All(fd, temperature, pressure, humidity)) { close(fd); return; } close(fd); #endif uint8_t forecast = CalculateForecast(((float)pressure) * 10.0f); int nforecast = wsbaroforecast_some_clouds; if (pressure <= 980) nforecast = wsbaroforecast_heavy_rain; else if (pressure <= 995) { if (temperature > 1) nforecast = wsbaroforecast_rain; else nforecast = wsbaroforecast_snow; } else if (pressure >= 1029) nforecast = wsbaroforecast_sunny; switch (forecast) { case bmpbaroforecast_sunny: nforecast = wsbaroforecast_sunny; break; case bmpbaroforecast_cloudy: nforecast = wsbaroforecast_cloudy; break; case bmpbaroforecast_thunderstorm: nforecast = wsbaroforecast_heavy_rain; break; case bmpbaroforecast_rain: if (temperature > 1) nforecast = wsbaroforecast_rain; else nforecast = wsbaroforecast_snow; break; } SendTempHumBaroSensorFloat(1, 255, temperature, humidity, pressure, nforecast, "TempHumBaro"); }

I2C::I2C(const int ID, const _eI2CType DevType, const std::string &Address, const std::string &SerialPort, const int Mode1); I2C::~I2C(); bool I2C::StartHardware(); bool I2C::StopHardware(); bool I2C::WriteToHardware(const char *pdata, const unsigned char /*length*/); void I2C::Do_Work(); bool I2C::i2c_test(const char *I2CBusName); int I2C::i2c_Open(const char *I2CBusName); void I2C::PCF8574_ReadChipDetails(); int I2C::PCF8574_WritePin(uint8_t pin_number, uint8_t value); void I2C::MCP23017_Init(); void I2C::MCP23017_ReadChipDetails(); int I2C::MCP23017_WritePin(uint8_t pin_number, uint8_t value); int I2C::ReadInt(int fd, uint8_t *devValues, uint8_t startReg, uint8_t bytesToRead); int I2C::WriteCmdAddr(const int fd, const uint8_t CmdAddr, const uint8_t devAction); int I2C::WriteCmd(int fd, uint8_t devAction); int I2C::readByteI2C(int fd, uint8_t *byte, uint8_t i2c_addr); int I2C::writeByteI2C(int fd, uint8_t byte, uint8_t i2c_addr); int I2C::I2CWriteReg16(int fd, uint8_t reg, uint16_t value); int I2C::I2CReadReg16(int fd, unsigned char reg, i2c_data *data); int I2C::HTU21D_checkCRC8(uint16_t data); int I2C::HTU21D_GetHumidity(int fd, float *Hum); int I2C::HTU21D_GetTemperature(int fd, float *Temp); void I2C::HTU21D_ReadSensorDetails(); void I2C::TSL2561_Init(); void I2C::TSL2561_ReadSensorDetails(); int I2C::bmp_Calibration(int fd); int I2C::bmp_WaitForConversion(int fd); int I2C::bmp_GetPressure(int fd, double *Pres); int I2C::bmp_GetTemperature(int fd, double *Temp); double I2C::bmp_altitude(double p); double I2C::bmp_qnh(double p, double StationAlt); double I2C::bmp_ppl_DensityAlt(double PAlt, double Temp); uint8_t I2C::bmp_CalculateForecast(const float pressure); uint8_t I2C::CalculateForecast(const float pressure); void I2C::bmp_Read_BMP_SensorDetails(); bool I2C::readBME280ID(const int fd, int &ChipID, int &Version); int16_t getShort(uint8_t *data, int index); uint16_t getUShort(uint8_t *data, int index); int8_t getChar(uint8_t *data, int index); uint8_t getUChar(uint8_t *data, int index); bool I2C::readBME280All(const int fd, float &temp, float &pressure, int &humidity);

f447189bdf03aabd3f6aa3e5e6da6d79333ae58c3ab66f4e3345eeb575b8da8c

RaisingTheDerp

raisingthebar

root/engine/net_ws.cpp

NET_ThreadUnlock

void NET_ThreadUnlock( void ) { #if defined( _WIN32 ) if ( use_thread && net_thread_initialized ) { LeaveCriticalSection( &net_cs ); } #endif }

void NET_ThreadLock( void ); void NetadrToSockadr (netadr_t *a, struct sockaddr *s); void SockadrToNetadr (struct sockaddr *s, netadr_t *a); unsigned short NET_HostToNetShort( unsigned short us_in ); unsigned short NET_NetToHostShort( unsigned short us_in ); qboolean NET_CompareAdr (netadr_t a, netadr_t b); qboolean NET_CompareClassBAdr (netadr_t a, netadr_t b); qboolean NET_IsReservedAdr (netadr_t a); qboolean NET_CompareBaseAdr (netadr_t a, netadr_t b); const char *NET_AdrToString (netadr_t a); const char *NET_BaseAdrToString (netadr_t a); qboolean NET_StringToSockaddr ( const char *s, struct sockaddr *sadr ); qboolean NET_StringToAdr ( const char *s, netadr_t *a); qboolean NET_IsLocalAddress (netadr_t adr); char *NET_ErrorString (int code); char *NET_ErrorString (int code); void NET_TransferRawData( sizebuf_t *msg, unsigned char *pStart, int nSize ); qboolean NET_GetLoopPacket (netsrc_t sock, netadr_t *in_from, sizebuf_t *msg ); void NET_SendLoopPacket (netsrc_t sock, int length, void *data, netadr_t to); void NET_RemoveFromPacketList(packetlag_t *pPacket); int NET_CountLaggedList( packetlag_t *pList ); void NET_ClearLaggedList(packetlag_t *pList); void NET_AddToLagged(netsrc_t sock, packetlag_t *pList, packetlag_t *pPacket, netadr_t *net_from, sizebuf_t messagedata, float timestamp ); void NET_AdjustLag( void ); qboolean NET_LagPacket (qboolean newdata, netsrc_t sock, netadr_t *from, sizebuf_t *data); CSplitPacketEntry(); void NET_DiscardStaleSplitpackets( void ); CSplitPacketEntry *NET_FindOrCreateSplitPacketEntry( netadr_t *from ); qboolean NET_GetLong( netadr_t *from, byte *pData, int size, int *outSize ); qboolean NET_QueuePacket (netsrc_t sock); int NET_Sleep( void ); DWORD NET_ThreadFunc( LPVOID pv ); void NET_StartThread( void ); void NET_StopThread( void ); void *net_malloc( size_t size ); net_messages_t *NET_AllocMsg( int size ); void NET_FreeMsg( net_messages_t *pmsg ); qboolean NET_GetPacket (netsrc_t sock); void NET_AllocateQueues( void ); void NET_FlushQueues( void ); int NET_SendTo( bool verbose, SOCKET s, const char FAR * buf, int len, int flags, const struct sockaddr FAR * to, int tolen ); char const *NET_GetDebugFilename( char const *prefix ); void NET_StorePacket( char const *filename, byte const *buf, int len ); char const *NET_GetPlayerNameForAdr( netadr_t *adr ); int NET_SendLong( netsrc_t sock, SOCKET s, const char FAR * buf, int len, int flags, const struct sockaddr FAR * to, int tolen ); void NET_SendPacket (netsrc_t sock, int length, void *data, netadr_t to); int NET_IPSocket ( const char *net_interface, int& port); void NET_OpenIP (void); char const *NET_GetHostName(); void NET_GetLocalAddress (void); int NET_IsConfigured( void ); void NET_Config (qboolean multiplayer); void NET_Init (); void NET_ClearLagData( qboolean bClient, qboolean bServer ); void NET_Shutdown (void);

0e2919b61b2e5e6f08fcb9a2e5d922fbf1b329e4ef91af981129512471af027a

WNProject

WNFramework

externals/librocket/Source/Core/Element.cpp

Element::ReleaseDeletedElements

void Element::ReleaseDeletedElements() { for (size_t i = 0; i < active_children.size(); i++) { active_children[i]->ReleaseDeletedElements(); } ReleaseElements(deleted_children); active_children = children; }

bool operator(); bool operator(); Element::Element(Core::Context* _context, const String& _tag); Element::~Element(); void Element::Update(); void Element::Render(); Element* Element::Clone(); void Element::SetClass(const String& class_name, bool activate); bool Element::IsClassSet(const String& class_name); void Element::SetClassNames(const String& class_names); String Element::GetClassNames(); StyleSheet* Element::GetStyleSheet(); const ElementDefinition* Element::GetDefinition(); String Element::GetAddress(bool include_pseudo_classes); Vector2f Element::GetRelativeOffset(Box::Area area); Vector2f Element::GetAbsoluteOffset(Box::Area area); void Element::SetClientArea(Box::Area _client_area); Box::Area Element::GetClientArea(); void Element::SetBox(const Box& box); void Element::AddBox(const Box& box); const Box& Element::GetBox(int index); int Element::GetNumBoxes(); float Element::GetBaseline(); bool Element::IsPointWithinElement(const Vector2f& point); bool Element::IsVisible(); float Element::GetZIndex(); FontFaceHandle* Element::GetFontFaceHandle(); bool Element::SetProperty(const String& name, const String& value); void Element::RemoveProperty(const String& name); bool Element::SetProperty(const String& name, const Property& property); const Property* Element::GetProperty(const String& name); const Property* Element::GetLocalProperty(const String& name); float Element::ResolveProperty(const String& name, float base_value); float Element::ResolveProperty(const Property* property, float base_value); void Element::GetOverflow(int* overflow_x, int* overflow_y); int Element::GetPosition(); int Element::GetFloat(); int Element::GetDisplay(); int Element::GetWhitespace(); const Property* Element::GetLineHeightProperty(); int Element::GetTextAlign(); int Element::GetTextTransform(); const Property* Element::GetVerticalAlignProperty(); void Element::SetPseudoClass(const String& pseudo_class, bool activate); bool Element::IsPseudoClassSet(const String& pseudo_class); bool Element::ArePseudoClassesSet(const PseudoClassList& pseudo_classes); const PseudoClassList& Element::GetActivePseudoClasses(); Variant* Element::GetAttribute(const String& name); bool Element::HasAttribute(const String& name); void Element::RemoveAttribute(const String& name); Element* Element::GetFocusLeafNode(); DocumentContext* Element::GetContext(); void Element::SetAttributes(const ElementAttributes* _attributes); int Element::GetNumAttributes(); const String& Element::GetTagName(); const String& Element::GetId(); void Element::SetId(const String& _id); float Element::GetAbsoluteLeft(); float Element::GetAbsoluteTop(); float Element::GetClientLeft(); float Element::GetClientTop(); float Element::GetClientWidth(); float Element::GetClientHeight(); Element* Element::GetOffsetParent(); float Element::GetOffsetLeft(); float Element::GetOffsetTop(); float Element::GetOffsetWidth(); float Element::GetOffsetHeight(); float Element::GetScrollLeft(); void Element::SetScrollLeft(float scroll_left); float Element::GetScrollTop(); void Element::SetScrollTop(float scroll_top); float Element::GetScrollWidth(); float Element::GetScrollHeight(); ElementStyle* Element::GetStyle(); ElementDocument* Element::GetOwnerDocument(); Element* Element::GetParentNode(); Element* Element::GetNextSibling(); Element* Element::GetPreviousSibling(); Element* Element::GetFirstChild(); Element* Element::GetLastChild(); Element* Element::GetChild(int index); int Element::GetNumChildren(bool include_non_dom_elements); void Element::GetInnerRML(String& content); String Element::GetInnerRML(); void Element::SetInnerRML(const String& rml); bool Element::Focus(); void Element::Blur(); void Element::Click(); void Element::ScrollIntoView(bool align_with_top); void Element::AppendChild(Element* child, bool dom_element); void Element::InsertBefore(Element* child, Element* adjacent_element); bool Element::RemoveChild(Element* child); bool Element::HasChildNodes(); Element* Element::GetElementById(const String& _id); void Element::GetElementsByTagName(ElementList& elements, const String& _tag); EventDispatcher* Element::GetEventDispatcher(); ElementBackground* Element::GetElementBackground(); ElementBorder* Element::GetElementBorder(); ElementDecoration* Element::GetElementDecoration(); ElementScroll* Element::GetElementScroll(); int Element::GetClippingIgnoreDepth(); bool Element::IsClippingEnabled(); RenderInterface* Element::GetRenderInterface(); void Element::SetInstancer(ElementInstancer* _instancer); void Element::ForceLocalStackingContext(); void Element::OnAttributeChange(const AttributeNameList& changed_attributes); void Element::OnPropertyChange(const PropertyNameList& changed_properties); void Element::OnChildAdd(Element* child); void Element::OnChildRemove(Element* child); void Element::UpdateLayout(); void Element::DirtyLayout(); void Element::LockLayout(bool lock); bool Element::IsLayoutDirty(); void Element::DirtyFont(); void Element::OnReferenceDeactivate(); void Element::ProcessEvent(Event& event); void Element::GetRML(String& content); void Element::SetParent(Element* _parent); void Element::ReleaseElements(ElementList& released_elements); void Element::DirtyOffset(); void Element::UpdateOffset(); void Element::BuildLocalStackingContext(); void Element::BuildStackingContext(ElementList* new_stacking_context); void Element::DirtyStackingContext(); void Element::DirtyStructure();

332b97c6316a0152fe80dfa7b6cc677c3d07d4edd210a73e60ef6aae2a41f172

AwkwardDev

TrilliumEMU

dep/g3dlite/source/CollisionDetection.cpp

CollisionDetection::penetrationDepthForFixedSphereFixedBox

float CollisionDetection::penetrationDepthForFixedSphereFixedBox( const Sphere& sphere, const Box& box, Array<Vector3>& contactPoints, Array<Vector3>& contactNormals) { contactPoints.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); contactNormals.resize(0, DONT_SHRINK_UNDERLYING_ARRAY); Vector3 halfExtent(box.extent(0), box.extent(1), box.extent(2)); halfExtent *= 0.5f; CoordinateFrame boxFrame; box.getLocalFrame(boxFrame); Vector3 center = boxFrame.pointToObjectSpace(sphere.center); Vector3 distOutsideBox; Vector3 centerRegion; Vector3 constant, variable; int numNonZero = 0; for (int a = 0; a < 3; ++a) { float distanceFromLow = -halfExtent[a] - center[a]; float distanceFromHigh = center[a] - halfExtent[a]; if (fabsf(distanceFromLow) < fabsf(distanceFromHigh)) { distOutsideBox[a] = distanceFromLow; } else { distOutsideBox[a] = distanceFromHigh; } if (distanceFromLow < 0.0) { if (distanceFromHigh < 0.0) { centerRegion[a] = 0.0; variable[a] = 1.0; } else { centerRegion[a] = 1.0; constant[a] = halfExtent[a]; ++numNonZero; } } else if (distanceFromHigh < 0.0) { centerRegion[a] = -1.0; constant[a] = -halfExtent[a]; ++numNonZero; } else { debugAssertM(false, "distanceFromLow and distanceFromHigh cannot both be positive"); } } float d2 = Vector3::zero().max(distOutsideBox).squaredMagnitude(); if (d2 > square(sphere.radius)) { return -1; } double depth = -1; switch (numNonZero) { case 3: contactNormals.append(boxFrame.normalToWorldSpace(constant - center)); contactPoints.append(boxFrame.pointToWorldSpace(constant)); depth = sphere.radius - sqrt(d2); break; case 2: { Line line = Line::fromPointAndDirection(constant, variable); depth = sphere.radius - sqrt(d2); Vector3 X = line.closestPoint(center); contactNormals.append(boxFrame.normalToWorldSpace(X - center).direction()); contactPoints.append(boxFrame.pointToWorldSpace(X)); } break; case 1: { Vector3 N = boxFrame.normalToWorldSpace(-centerRegion); contactNormals.append(N); depth = sphere.radius - sqrtf(d2); contactPoints.append(sphere.center + N * (sphere.radius - depth)); } break; case 0: contactPoints.append(sphere.center); if (distOutsideBox.x > distOutsideBox.y) { if (distOutsideBox.x > distOutsideBox.z) { if (center.x > 0) { contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitX())); } else { contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitX())); } depth = -distOutsideBox.x; } else { goto ZAXIS; } } else if (distOutsideBox.y > distOutsideBox.z) { if (center.y > 0) { contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitY())); } else { contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitY())); } depth = -distOutsideBox.y; } else { ZAXIS: if (center.z > 0) { contactNormals.append(boxFrame.normalToWorldSpace(-Vector3::unitZ())); } else { contactNormals.append(boxFrame.normalToWorldSpace(Vector3::unitZ())); } depth = -distOutsideBox.z; } break; default: debugAssertM(false, "Fell through switch"); break; } return depth; }

tatic bool planeBoxOverlap(const Vector3& normal, const Vector3& vert, const Vector3& maxbox); ool CollisionDetection::fixedSolidBoxIntersectsFixedTriangle( const AABox& box, const Triangle& tri);

409c66418df2dcd00996868af476c11121541c6859d3d675d5aff031c472d6ce

UCI-CARL

CARLsim4

carlsim/test/interface.cpp

TEST

TEST(Interface, setWeightDeath) { ::testing::FLAGS_gtest_death_test_style = "threadsafe"; CARLsim* sim = new CARLsim("Interface.setWeightDeath",CPU_MODE,SILENT,1,42); int g1=sim->createGroup("excit", Grid3D(10,10,1), EXCITATORY_NEURON); sim->setNeuronParameters(g1, 0.02f, 0.2f,-65.0f,8.0f); int c1=sim->connect(g1, g1, "full", RangeWeight(0.01), 1.0f, RangeDelay(1)); EXPECT_DEATH({sim->setWeight(c1, 0, 0, 0.1, false);},""); sim->setConductances(true); sim->setupNetwork(); sim->runNetwork(0,20); EXPECT_DEATH({sim->setWeight(c1+1, 0, 0, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(-1, 0, 0, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(0, -1, 0, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(0, 101, 0, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(0, 0, -1, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(0, 0,101, 0.1, false);},""); EXPECT_DEATH({sim->setWeight(0, 0, 0, -1.0, false);},""); if (sim!=NULL) delete sim; }

void connect(CARLsim* net, int srcGrp, int i, int destGrp, int j, float& weight, float& maxWt, float& delay, bool& connected); TEST(Interface, connectDeath); TEST(Interface, connectCompartmentsDeath); TEST(Interface, createGroupDeath); TEST(Interface, createSpikeGeneratorGroupDeath); TEST(Interface, getGroupGrid3DDeath); TEST(Interface, getNeuronLocation3DDeath); TEST(Interface, loggerDeath); TEST(Interface, biasWeightsDeath); TEST(Interface, scaleWeightsDeath); TEST(Interface, getDelayRangeDeath); TEST(Interface, getWeightRangeDeath); TEST(Interface, setConductancesDeath); TEST(Interface, setExternalCurrentDeath); TEST(Interface, setHomeostasisDeath); TEST(Interface, setNeuronParametersDeath); TEST(Interface, setDefaultConductanceTimeConstants); TEST(Interface, CARLsimState); TEST(Interface, setDefaultSTDPparamsDeath); TEST(Interface, setSTDPDeath);

8d43a4bc7b30fa151534eab963f0a9266d4a674cf5fe789caee80c40e01945d4

whdlgp

ARMv6m_Simulator

tests/branchInstrTest.cpp

test_bBGT_Taken2

void test_bBGT_Taken2() { printf (" %s \n", __FUNCTION__); setInitialRegisterValues(); clearZero(); setNegative(); setOverflow(); emitInstruction16("1101cccciiiiiiii", COND_GT, 0); setExpectedXPSRflags("zNV"); setExpectedRegisterValue(PC, INITIAL_PC + 4); }

void test_bBEQ_NotTaken(); void test_bBEQ_Taken(); void test_bBNE_NotTaken(); void test_bBNE_Taken(); void test_bBCS_NotTaken(); void test_bBCS_Taken(); void test_bBCC_NotTaken(); void test_bBCC_Taken(); void test_bBMI_NotTaken(); void test_bBMI_Taken(); void test_bBPL_NotTaken(); void test_bBPL_Taken(); void test_bBVS_NotTaken(); void test_bBVS_Taken(); void test_bBVC_NotTaken(); void test_bBVC_Taken(); void test_bBHI_NotTaken(); void test_bBHI_Taken(); void test_bBLS_NotTaken(); void test_bBLS_Taken(); void test_bBGE_NotTaken(); void test_bBGE_Taken1(); void test_bBGE_Taken2(); void test_bBLT_NotTaken(); void test_bBLT_Taken1(); void test_bBLT_Taken2(); void test_bBGT_NotTaken(); void test_bBGT_Taken1(); void test_bBLE_NotTaken(); void test_bBLE_Taken1(); void test_bBLE_Taken2(); void test_bBEQ_TakenWithLargestPositiveOffset(); void test_bBEQ_TakenWithLargesNegativeOffset(); void test_bBAL_ZeroOffset(); void test_bBAL_LargestPositiveOffset(); void test_bBAL_LargestNegativeOffset();

fe24b369c2554081b7a4892bfd07f3996978980f89f02fa9a2b399fc05772e66

FakelsHub

sfall

sfall/Modules/Movies.cpp

__declspec

static void __declspec(naked) gmovie_play_hook() { __asm { push ecx; call fo::funcoffs::get_input_; mov ecx, eax; call PlayMovieLoop; pop ecx; retn; }

HRESULT __stdcall TerminateDevice(DWORD_PTR dwID); HRESULT __stdcall QueryInterface(const IID &riid, void** ppvObject); HRESULT __stdcall InitializeDevice(DWORD_PTR dwUserID, VMR9AllocationInfo *lpAllocInfo, DWORD *lpNumBuffers); HRESULT __stdcall GetSurface(DWORD_PTR dwUserID, DWORD surfaceIndex, DWORD surfaceFlags, IDirect3DSurface9 **lplpSurface); HRESULT __stdcall StartPresenting(DWORD_PTR dwUserID); HRESULT __stdcall StopPresenting(DWORD_PTR dwUserID); HRESULT __stdcall PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo *lpPresInfo); CAllocator(); ULONG __stdcall AddRef(); ULONG __stdcall Release(); HRESULT __stdcall AdviseNotify(IVMRSurfaceAllocatorNotify9 *lpIVMRSurfAllocNotify); bool IsInitialized(); static void PlayMovie(sDSTexture* movie); static void StopMovie(); DWORD FreeMovie(sDSTexture* movie); static void BreakMovie(); DWORD CreateDSGraph(wchar_t* path, sDSTexture* movie); static DWORD __fastcall PlayMovieLoop(long kCode); static void __declspec(naked); static void __stdcall PreparePlayMovie(); static void __declspec(naked); static DWORD __fastcall PrepareLoadMovie(const DWORD id); static void __stdcall PlayMovieRestore(); static void __declspec(naked); static void __declspec(naked); static void __declspec(naked); static void __declspec(naked); static void __declspec(naked); void SkipOpeningMoviesPatch(); static __declspec(naked); bool Movies::DirectShowMovies(); void Movies::init(); void Movies::exit();

36830bad05e6b45cd594d0452efbc44915ed180f902b98817d3e589721fce1c5

keera-studios

hsQt

qws/src/gui/QGraphicsItemGroup.cpp

QTCEXPORT

QTCEXPORT(int, qtc_QGraphicsItemGroup_unSetUserMethod)(void * evt_obj, int udm_typ, int evt_typ) { void * te = evt_obj; return (int) ((DhQGraphicsItemGroup*)te)->unSetDynamicQHandlerud(udm_typ, evt_typ); }

QTCEXPORT(void*,qtc_QGraphicsItemGroup); QTCEXPORT(void*,qtc_QGraphicsItemGroup1); QTCEXPORT(void*,qtc_QGraphicsItemGroup1_graphicstextitem); QTCEXPORT(void*,qtc_QGraphicsItemGroup2); QTCEXPORT(void*,qtc_QGraphicsItemGroup2_graphicstextitem); QTCEXPORT(void,qtc_QGraphicsItemGroup_addToGroup); QTCEXPORT(void,qtc_QGraphicsItemGroup_addToGroup_graphicstextitem); QTCEXPORT(void*,qtc_QGraphicsItemGroup_boundingRect); QTCEXPORT(void*,qtc_QGraphicsItemGroup_boundingRect_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_boundingRect_qth); QTCEXPORT(void,qtc_QGraphicsItemGroup_boundingRect_qth_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy); QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_graphicstextitem); QTCEXPORT(int,qtc_QGraphicsItemGroup_isObscuredBy_graphicstextitem_h); QTCEXPORT(void*,qtc_QGraphicsItemGroup_opaqueArea); QTCEXPORT(void*,qtc_QGraphicsItemGroup_opaqueArea_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_paint); QTCEXPORT(void,qtc_QGraphicsItemGroup_paint1); QTCEXPORT(void,qtc_QGraphicsItemGroup_paint1_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromGroup); QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromGroup_graphicstextitem); QTCEXPORT(int,qtc_QGraphicsItemGroup_type); QTCEXPORT(int,qtc_QGraphicsItemGroup_type_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_finalizer); QTCEXPORT(void*,qtc_QGraphicsItemGroup_getFinalizer); QTCEXPORT(void,qtc_QGraphicsItemGroup_finalizer1); QTCEXPORT(void*,qtc_QGraphicsItemGroup_getFinalizer1); QTCEXPORT(void,qtc_QGraphicsItemGroup_delete); QTCEXPORT(void,qtc_QGraphicsItemGroup_delete1); QTCEXPORT(void,qtc_QGraphicsItemGroup_addToIndex); QTCEXPORT(void,qtc_QGraphicsItemGroup_advance); QTCEXPORT(void,qtc_QGraphicsItemGroup_advance_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_graphicstextitem); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem_graphicstextitem_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_graphicstextitem); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithItem1_graphicstextitem_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath1); QTCEXPORT(int,qtc_QGraphicsItemGroup_collidesWithPath1_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_contains); QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_qth); QTCEXPORT(int,qtc_QGraphicsItemGroup_contains_qth_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_contextMenuEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_contextMenuEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragEnterEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragEnterEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragLeaveEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragLeaveEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragMoveEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_dragMoveEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_dropEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_dropEvent_h); QTCEXPORT(void*,qtc_QGraphicsItemGroup_extension); QTCEXPORT(void,qtc_QGraphicsItemGroup_focusInEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_focusInEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_focusOutEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_focusOutEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverEnterEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverEnterEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverLeaveEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverLeaveEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverMoveEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_hoverMoveEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_inputMethodEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_inputMethodEvent_h); QTCEXPORT(void*,qtc_QGraphicsItemGroup_inputMethodQuery); QTCEXPORT(void*,qtc_QGraphicsItemGroup_inputMethodQuery_h); QTCEXPORT(void*,qtc_QGraphicsItemGroup_itemChange); QTCEXPORT(void*,qtc_QGraphicsItemGroup_itemChange_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_keyPressEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_keyPressEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_keyReleaseEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_keyReleaseEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseDoubleClickEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseDoubleClickEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseMoveEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseMoveEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_mousePressEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_mousePressEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseReleaseEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_mouseReleaseEvent_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_prepareGeometryChange); QTCEXPORT(void,qtc_QGraphicsItemGroup_removeFromIndex); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEvent); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEvent_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_graphicstextitem); QTCEXPORT(int,qtc_QGraphicsItemGroup_sceneEventFilter_graphicstextitem_h); QTCEXPORT(void,qtc_QGraphicsItemGroup_setExtension); QTCEXPORT(void*,qtc_QGraphicsItemGroup_shape); QTCEXPORT(void*,qtc_QGraphicsItemGroup_shape_h); QTCEXPORT(int,qtc_QGraphicsItemGroup_supportsExtension); QTCEXPORT(void,qtc_QGraphicsItemGroup_wheelEvent); QTCEXPORT(void,qtc_QGraphicsItemGroup_wheelEvent_h); QTCEXPORT(void, qtc_QGraphicsItemGroup_userMethod); QTCEXPORT(void*, qtc_QGraphicsItemGroup_userMethodVariant); QTCEXPORT(int, qtc_QGraphicsItemGroup_setUserMethod); QTCEXPORT(int, qtc_QGraphicsItemGroup_setUserMethodVariant); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler); QTCEXPORT(int, qtc_QGraphicsItemGroup_unSetHandler); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler1); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler2); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler3); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler4); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler5); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler6); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler7); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler8); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler9); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler10); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler11); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler12); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler13); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler14); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler15); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler16); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler17); QTCEXPORT(int, qtc_QGraphicsItemGroup_setHandler18);

e0937c5c8b3f8838407e592fbb6f63b7f0379ffc054ace56fedeb04c33e49e7a

goodwinxp

Yorozuya

YorozuyaGSLib/source/CPlayerDetail.cpp

CPlayerSendMsg_MovePortal872_wrapper

void CPlayerSendMsg_MovePortal872_wrapper(struct CPlayer* _this, char byRet, char byMapIndex, char byPotalIndex, float* pfStartPos, bool bEqualZone) { CPlayerSendMsg_MovePortal872_user(_this, byRet, byMapIndex, byPotalIndex, pfStartPos, bEqualZone, CPlayerSendMsg_MovePortal872_next); }

void CPlayerAddDalant2_wrapper(struct CPlayer* _this, unsigned int dwPush, bool bApply); void CPlayerAddGold4_wrapper(struct CPlayer* _this, unsigned int dwPush, bool bApply); void CPlayerAlterDalant6_wrapper(struct CPlayer* _this, long double dDalant); void CPlayerAlterExp8_wrapper(struct CPlayer* _this, long double dAlterExp, bool bReward, bool bUseExpRecoverItem, bool bUseExpAdditionItem); void CPlayerAlterExp_Animus10_wrapper(struct CPlayer* _this, int64_t nAlterExp); void CPlayerAlterExp_Potion12_wrapper(struct CPlayer* _this, long double dAlterExp); void CPlayerAlterFP_Animus14_wrapper(struct CPlayer* _this, int nNewFP); void CPlayerAlterGold16_wrapper(struct CPlayer* _this, long double dGold); void CPlayerAlterHP_Animus18_wrapper(struct CPlayer* _this, int nNewHP); void CPlayerAlterMaxLevel20_wrapper(struct CPlayer* _this, char byMaxLevel); void CPlayerAlterMode_Animus22_wrapper(struct CPlayer* _this, char byMode); void CPlayerAlterPvPCashBag24_wrapper(struct CPlayer* _this, long double dAlter, PVP_MONEY_ALTER_TYPE IOCode); void CPlayerAlterPvPPoint26_wrapper(struct CPlayer* _this, long double dAlter, PVP_ALTER_TYPE AlterType, unsigned int dwDstSerial); void CPlayerAlterPvpPointLeak28_wrapper(struct CPlayer* _this, long double dAlter); void CPlayerAlterSec30_wrapper(struct CPlayer* _this); bool CPlayerApplyEquipItemEffect32_wrapper(struct CPlayer* _this, int iItemEffectCode, bool bEquip); void CPlayerApplySetItemEffect34_wrapper(struct CPlayer* _this, struct si_interpret* pSI, unsigned int dwSetItem, char bySetItemNum, char bySetEffectNum, bool bSetEffect); int CPlayerAttackableHeight36_wrapper(struct CPlayer* _this); void CPlayerAutoCharge_Booster38_wrapper(struct CPlayer* _this); void CPlayerAutoRecover40_wrapper(struct CPlayer* _this); void CPlayerAutoRecover_Animus42_wrapper(struct CPlayer* _this); void CPlayerBilling_Logout44_wrapper(struct CPlayer* _this); void CPlayerBreakCloakBooster46_wrapper(struct CPlayer* _this); void CPlayerctor_CPlayer48_wrapper(struct CPlayer* _this); long double CPlayerCalPvpCashPoint50_wrapper(struct CPlayer* _this, int nDstLv, int nSrcLv, char* pSrcClass); void CPlayerCalPvpTempCash52_wrapper(struct CPlayer* _this, struct CPlayer* pDier, char byKillerObjID); void CPlayerCalcAddPointByClass54_wrapper(struct CPlayer* _this); uint16_t CPlayerCalcCurFPRate56_wrapper(struct CPlayer* _this); uint16_t CPlayerCalcCurHPRate58_wrapper(struct CPlayer* _this); uint16_t CPlayerCalcCurSPRate60_wrapper(struct CPlayer* _this); float CPlayerCalcDPRate62_wrapper(struct CPlayer* _this); void CPlayerCalcDefTol64_wrapper(struct CPlayer* _this); int CPlayerCalcEquipAttackDelay66_wrapper(struct CPlayer* _this); void CPlayerCalcEquipMaxDP68_wrapper(struct CPlayer* _this, bool bInit); void CPlayerCalcEquipSpeed70_wrapper(struct CPlayer* _this); void CPlayerCalcExp72_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nDam, struct CPartyModeKillMonsterExpNotify* kPartyExpNotify); void CPlayerCalcPvP74_wrapper(struct CPlayer* _this, struct CPlayer* pDier, char byKillerObjID); void CPlayerCheckAlterMaxPoint76_wrapper(struct CPlayer* _this); void CPlayerCheckBattleMode78_wrapper(struct CPlayer* _this); void CPlayerCheckGroupMapPoint80_wrapper(struct CPlayer* _this); void CPlayerCheckGroupTargeting82_wrapper(struct CPlayer* _this); void CPlayerCheckMentalTakeAndUpdateLastMetalTicket84_wrapper(struct CPlayer* _this, char* strItemCode); void CPlayerCheckNameChange86_wrapper(struct CPlayer* _this); void CPlayerCheckPosInTown88_wrapper(struct CPlayer* _this); void CPlayerCheckPos_Region90_wrapper(struct CPlayer* _this); void CPlayerCheckUnitCutTime92_wrapper(struct CPlayer* _this); void CPlayerCheet_BufEffectEnd94_wrapper(struct CPlayer* _this); void CPlayerClearGravityStone96_wrapper(struct CPlayer* _this); bool CPlayerCorpse98_wrapper(struct CPlayer* _this, struct CCharacter* pAtter); bool CPlayerCreate100_wrapper(struct CPlayer* _this); void CPlayerCreateComplete102_wrapper(struct CPlayer* _this); void CPlayerDTradeInit104_wrapper(struct CPlayer* _this); bool CPlayerDecHalfSFContDam106_wrapper(struct CPlayer* _this, float fEffVal); void CPlayerDelPostData108_wrapper(struct CPlayer* _this, unsigned int dwIndex); void CPlayerDeleteCouponItem110_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* CouponItem, int n); bool CPlayerDeleteUseConsumeItem112_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con** ppConsumeItems, int* pnConsume, bool* pbOverLap); struct _STORAGE_LIST::_db_con* CPlayerEmb_AddStorage114_wrapper(struct CPlayer* _this, char byStorageCode, struct _STORAGE_LIST::_storage_con* pCon, bool bEquipChange, bool bAdd); unsigned int CPlayerEmb_AlterDurPoint116_wrapper(struct CPlayer* _this, char byStorageCode, char byStorageIndex, int nAlter, bool bUpdate, bool bSend); void CPlayerEmb_AlterStat118_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex, unsigned int dwAlter, char byReason, char* strErrorCodePos, bool bPcbangPrimiumFavorReward); void CPlayerEmb_AlterStat_F120_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex, float fAlter, char byReason); bool CPlayerEmb_CheckActForQuest122_wrapper(struct CPlayer* _this, int nActCode, char* pszReqCode, uint16_t wAddCount, bool bParty); void CPlayerEmb_CheckActForQuestParty124_wrapper(struct CPlayer* _this, int nActCode, char* pszReqCode, uint16_t wAddCount); void CPlayerEmb_CompleteQuest126_wrapper(struct CPlayer* _this, char byQuestDBSlot, char byRewardItemIndex, char byLinkQuestIndex); bool CPlayerEmb_CreateNPCQuest128_wrapper(struct CPlayer* _this, char* pszEventCode, unsigned int dwNPCQuestIndex); bool CPlayerEmb_CreateQuestEvent130_wrapper(struct CPlayer* _this, QUEST_HAPPEN HappenType, char* pszEventCode); bool CPlayerEmb_DelStorage132_wrapper(struct CPlayer* _this, char byStorageCode, char byStorageIndex, bool bEquipChange, bool bDelete, char* strErrorCodePos); void CPlayerEmb_EquipLink134_wrapper(struct CPlayer* _this); void CPlayerEmb_ItemUpgrade136_wrapper(struct CPlayer* _this, char byUpgradeType, char byStorageCode, char byStorageIndex, unsigned int dwGradeInfo); void CPlayerEmb_RidindUnit138_wrapper(struct CPlayer* _this, bool bRiding, struct CParkingUnit* pCreateUnit); bool CPlayerEmb_StartQuest140_wrapper(struct CPlayer* _this, char bySelectQuest, struct _happen_event_cont* pHappenEvent); int CPlayerEmb_UpdateStat142_wrapper(struct CPlayer* _this, unsigned int dwStatIndex, unsigned int dwNewData, unsigned int dwOldData); void CPlayerExitUpdateDataToWorld144_wrapper(struct CPlayer* _this); void CPlayerExtractStringToTime146_wrapper(struct CPlayer* _this, unsigned int dwTemp, struct _SYSTEMTIME* tm); struct CPlayer* CPlayerFindFarChatPlayerWithTemp148_wrapper(struct CPlayer* _this, char* pwszName); bool CPlayerFixTargetWhile150_wrapper(struct CPlayer* _this, struct CCharacter* pkTarget, unsigned int dwMiliSecond); void CPlayerForcePullUnit152_wrapper(struct CPlayer* _this, bool bLogout); float CPlayerGetAddSpeed154_wrapper(struct CPlayer* _this); struct _sf_continous* CPlayerGetAfterEffect156_wrapper(struct CPlayer* _this); int CPlayerGetAttackDP158_wrapper(struct CPlayer* _this); int CPlayerGetAttackLevel160_wrapper(struct CPlayer* _this); float CPlayerGetAttackRange162_wrapper(struct CPlayer* _this); int CPlayerGetAvoidRate164_wrapper(struct CPlayer* _this); int CPlayerGetBillingType166_wrapper(struct CPlayer* _this); struct _dummy_position* CPlayerGetBindDummy168_wrapper(struct CPlayer* _this); struct CMapData* CPlayerGetBindMap170_wrapper(struct CPlayer* _this, float* pfPos, bool bIgnoreMapClass); struct CMapData* CPlayerGetBindMapData172_wrapper(struct CPlayer* _this); int CPlayerGetCashAmount174_wrapper(struct CPlayer* _this); int CPlayerGetDP176_wrapper(struct CPlayer* _this); int CPlayerGetDamageDP178_wrapper(struct CPlayer* _this, int nAttackPart); int CPlayerGetDamageLevel180_wrapper(struct CPlayer* _this, int nAttackPart); int CPlayerGetDefFC182_wrapper(struct CPlayer* _this, int nAttactPart, struct CCharacter* pAttChar, int* pnConvertPart); float CPlayerGetDefFacing184_wrapper(struct CPlayer* _this, int nPart); float CPlayerGetDefGap186_wrapper(struct CPlayer* _this, int nPart); int CPlayerGetDefSkill188_wrapper(struct CPlayer* _this, bool bBackAttackDamage); char CPlayerGetEffectEquipCode190_wrapper(struct CPlayer* _this, char byStorageCode, char bySlotIndex); int CPlayerGetFP192_wrapper(struct CPlayer* _this); int CPlayerGetFireTol194_wrapper(struct CPlayer* _this); int CPlayerGetGauge196_wrapper(struct CPlayer* _this, int nParamCode); int CPlayerGetGenAttackProb198_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nPart, bool bBackAttack); struct CPlayer::__target* CPlayerGetGroupTarget200_wrapper(struct CPlayer* _this, char byGroupType); int CPlayerGetHP202_wrapper(struct CPlayer* _this); unsigned int CPlayerGetInitClassCost204_wrapper(struct CPlayer* _this); int CPlayerGetLevel206_wrapper(struct CPlayer* _this); int CPlayerGetMasteryCumAfterAttack208_wrapper(struct CPlayer* _this, int nDstLv); int CPlayerGetMaxDP210_wrapper(struct CPlayer* _this); int CPlayerGetMaxFP212_wrapper(struct CPlayer* _this); int CPlayerGetMaxHP214_wrapper(struct CPlayer* _this); int CPlayerGetMaxSP216_wrapper(struct CPlayer* _this); unsigned int CPlayerGetMoney218_wrapper(struct CPlayer* _this, char byMoneyCode); float CPlayerGetMoveSpeed220_wrapper(struct CPlayer* _this); char* CPlayerGetObjName222_wrapper(struct CPlayer* _this); int CPlayerGetObjRace224_wrapper(struct CPlayer* _this); float CPlayerGetPartyExpDistributionRate226_wrapper(struct CPlayer* _this, int iPartyMemberLevel, int iMaxLevel, int i2ndLevel); struct CPvpOrderView* CPlayerGetPvpOrderView228_wrapper(struct CPlayer* _this); long double CPlayerGetPvpPointLeak230_wrapper(struct CPlayer* _this); struct CPvpPointLimiter* CPlayerGetPvpPointLimiter232_wrapper(struct CPlayer* _this, struct CPvpPointLimiter* result); struct CAnimus* CPlayerGetRecallAnimus234_wrapper(struct CPlayer* _this); int CPlayerGetRewardItems_DarkDungeon236_wrapper(struct CPlayer* _this, struct _dh_reward_sub_setup* pSetup, struct _STORAGE_LIST::_db_con* pItems, int bRealBoss); int CPlayerGetSP238_wrapper(struct CPlayer* _this); int CPlayerGetSoilTol240_wrapper(struct CPlayer* _this); uint64_t CPlayerGetStateFlag242_wrapper(struct CPlayer* _this); struct CGameObject* CPlayerGetTargetObj244_wrapper(struct CPlayer* _this); bool CPlayerGetUseConsumeItem246_wrapper(struct CPlayer* _this, struct _consume_item_list* pConsumeList, uint16_t* pItemSerials, struct _STORAGE_LIST::_db_con** ppConsumeItems, int* pnConsume, bool* pbOverLap); int CPlayerGetVisualVer248_wrapper(struct CPlayer* _this); int CPlayerGetWaterTol250_wrapper(struct CPlayer* _this); float CPlayerGetWeaponAdjust252_wrapper(struct CPlayer* _this); int CPlayerGetWeaponClass254_wrapper(struct CPlayer* _this); int CPlayerGetWeaponRange256_wrapper(struct CPlayer* _this); float CPlayerGetWidth258_wrapper(struct CPlayer* _this); int CPlayerGetWindTol260_wrapper(struct CPlayer* _this); void CPlayerGuild_Buy_Emblem_Complete262_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Disjoint_Complete264_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Force_Leave_Complete266_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Insert_Complete268_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Join_Accept_Complete270_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Pop_Money_Complete272_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Push_Money_Complete274_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Self_Leave_Complete276_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerGuild_Update_GuildMater_Complete278_wrapper(struct _DB_QRY_SYN_DATA* pData); void CPlayerHSKQuestEnd_Att280_wrapper(struct CPlayer* _this, char byDestroyStoneRaceCode, struct CPlayer* pDestroyer); void CPlayerHideNameEffect282_wrapper(struct CPlayer* _this, bool bAdd); void CPlayerIncCriEffKillPoint284_wrapper(struct CPlayer* _this); void CPlayerIncCriEffPvPCashBag286_wrapper(struct CPlayer* _this, long double dAlter); void CPlayerIncPvPPoint288_wrapper(struct CPlayer* _this, long double dAlter, PVP_ALTER_TYPE AlterType, unsigned int dwDstSerial); bool CPlayerInit290_wrapper(struct CPlayer* _this, struct _object_id* pID); bool CPlayerIntoMap292_wrapper(struct CPlayer* _this, char byMapInMode); bool CPlayerIsActingSiegeMode294_wrapper(struct CPlayer* _this); bool CPlayerIsApplyPcbangPrimium296_wrapper(struct CPlayer* _this); bool CPlayerIsBeAttackedAble298_wrapper(struct CPlayer* _this, bool bFirst); bool CPlayerIsBeDamagedAble300_wrapper(struct CPlayer* _this, struct CCharacter* pAtter); struct _STORAGE_LIST::_db_con* CPlayerIsBulletValidity302_wrapper(struct CPlayer* _this, uint16_t wBulletSerial); bool CPlayerIsChaosMode304_wrapper(struct CPlayer* _this); struct _STORAGE_LIST::_db_con* CPlayerIsEffBulletValidity306_wrapper(struct CPlayer* _this, uint16_t wEffBulletSerial); bool CPlayerIsEffectableEquip308_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_storage_con* pCon); bool CPlayerIsEquipAbleGrade310_wrapper(struct CPlayer* _this, char byGradeLv); bool CPlayerIsHaveMentalTicket312_wrapper(struct CPlayer* _this); bool CPlayerIsInTown314_wrapper(struct CPlayer* _this); bool CPlayerIsLastAttBuff316_wrapper(struct CPlayer* _this); bool CPlayerIsMapLoading318_wrapper(struct CPlayer* _this); bool CPlayerIsMineMode320_wrapper(struct CPlayer* _this); bool CPlayerIsMiningByMinigTicket322_wrapper(struct CPlayer* _this); bool CPlayerIsOutExtraStopPos324_wrapper(struct CPlayer* _this, float* pfStopPos); bool CPlayerIsOverOneDay326_wrapper(struct CPlayer* _this); bool CPlayerIsPassExpLimitLvDiff328_wrapper(struct CPlayer* _this, int iDstLevel, bool* bGetAttackExp); bool CPlayerIsPassMasteryLimitLvDiff330_wrapper(struct CPlayer* _this, int iDstLevel); bool CPlayerIsPunished332_wrapper(struct CPlayer* _this, char byType, bool bSend); bool CPlayerIsRecallAnimus334_wrapper(struct CPlayer* _this); bool CPlayerIsRecvableContEffect336_wrapper(struct CPlayer* _this); bool CPlayerIsReturnPostUpdate338_wrapper(struct CPlayer* _this); bool CPlayerIsRidingShip340_wrapper(struct CPlayer* _this); bool CPlayerIsRidingUnit342_wrapper(struct CPlayer* _this); bool CPlayerIsSFActableByClass344_wrapper(struct CPlayer* _this, char byEffectCode, struct _base_fld* pSFFld); bool CPlayerIsSFUsableGauge346_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, uint16_t* pwDelPoint); bool CPlayerIsSFUsableSFMastery348_wrapper(struct CPlayer* _this, char byMasteryCode, int nMasteryIndex); bool CPlayerIsSFUseableRace350_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex); bool CPlayerIsSiegeMode352_wrapper(struct CPlayer* _this); bool CPlayerIsTargetObj354_wrapper(struct CPlayer* _this, struct CGameObject* pkObj); bool CPlayerIsUsableAccountType356_wrapper(struct CPlayer* _this, int nCashType); bool CPlayerIsUseCloakBooster358_wrapper(struct CPlayer* _this); bool CPlayerIsUseReleaseRaceBuffPotion360_wrapper(struct CPlayer* _this); bool CPlayerIs_Battle_Mode362_wrapper(struct CPlayer* _this); void CPlayerLimLvNpcQuestDelete364_wrapper(struct CPlayer* _this, char byQuestDBSlot); bool CPlayerLoad366_wrapper(struct CPlayer* _this, struct CUserDB* pUser, bool bFirstStart); void CPlayerLoop368_wrapper(struct CPlayer* _this); void CPlayerNetClose370_wrapper(struct CPlayer* _this, bool bMoveOutLobby); void CPlayerNewViewCircleObject372_wrapper(struct CPlayer* _this); void CPlayerOnLoop_Static374_wrapper(); bool CPlayerOutOfMap376_wrapper(struct CPlayer* _this, struct CMapData* pIntoMap, uint16_t wLayerIndex, char byMapOutType, float* pfStartPos); void CPlayerOutOfSec378_wrapper(struct CPlayer* _this); void CPlayerPastWhisperInit380_wrapper(struct CPlayer* _this); void CPlayerPotion_Buf_Extend382_wrapper(struct CPlayer* _this); void CPlayerPushDQSCheatPlyerVoteInfo384_wrapper(struct CPlayer* _this); void CPlayerPushDQSUpdatePlyerVoteInfo386_wrapper(struct CPlayer* _this); void CPlayerPushDQSUpdateVoteAvilable388_wrapper(struct CPlayer* _this); void CPlayerReCalcMaxHFSP390_wrapper(struct CPlayer* _this, bool bSend, bool bRatio); void CPlayerRecallRandomPositionInRange392_wrapper(struct CPlayer* _this, struct CMapData* pIntoMap, uint16_t wMapLayerIndex, float* pStartPos, int iRange); void CPlayerRecvHSKQuest394_wrapper(struct CPlayer* _this, char byHSKQuestCode, char byCristalBattleDBInfo, int nPvpPoint, uint16_t wKillPoint, uint16_t wDieCount, char byHSKTime); void CPlayerRecvKillMessage396_wrapper(struct CPlayer* _this, struct CCharacter* pDier); void CPlayerReservationForceClose398_wrapper(struct CPlayer* _this); void CPlayerResurrect400_wrapper(struct CPlayer* _this); void CPlayerReturn_AnimusAsk402_wrapper(struct CPlayer* _this, char byReturnType); void CPlayerRewardChangeClass404_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld, char bySelectRewardItem); void CPlayerRewardChangeClassMastery406_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld); void CPlayerRewardChangeClassRewardItem408_wrapper(struct CPlayer* _this, struct _class_fld* pClassFld, char bySelectRewardItem); void CPlayerRewardRaceWarPvpCash410_wrapper(struct CPlayer* _this); void CPlayerReward_DarkDungeon412_wrapper(struct CPlayer* _this, struct _dh_reward_sub_setup* pSetup, char* pszTitle, int bRealBoss, struct _STORAGE_LIST::_db_con* pItem, int* bIsRewarded); bool CPlayerRobbedHP414_wrapper(struct CPlayer* _this, struct CCharacter* pDst, int nDecHP); void CPlayerSFContDelMessage416_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, bool bSend, bool bAura); void CPlayerSFContInsertMessage418_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, bool bAuraSkill, struct CPlayer* pPlayerAct); void CPlayerSFContUpdateTimeMessage420_wrapper(struct CPlayer* _this, char byContCode, char byListIndex, int nLeftTime); bool CPlayerSF_AllContDamageForceRemove_Once422_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_AllContDamageRemove_Once424_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_AllContHelpForceRemove_Once426_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_AllContHelpSkillRemove_Once428_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_AttHPtoDstFP_Once430_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_ContDamageTimeInc_Once432_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_ContHelpTimeInc_Once434_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_ConvertMonsterTarget436_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_ConvertTargetDest438_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_DamageAndStun440_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_FPDec442_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_HFSInc_Once444_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_HPInc_Once446_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_IncHPCircleParty448_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_IncreaseDP450_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_LateContDamageRemove_Once452_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_LateContHelpForceRemove_Once454_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_LateContHelpSkillRemove_Once456_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_MakePortalReturnBindPositionPartyMember458_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue, char* byRet); bool CPlayerSF_MakeZeroAnimusRecallTimeOnce460_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_OthersContHelpSFRemove_Once462_wrapper(struct CPlayer* _this, float fEffectValue); bool CPlayerSF_OverHealing_Once464_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_RecoverAllReturnStateAnimusHPFull466_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_ReleaseMonsterTarget468_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_RemoveAllContHelp_Once470_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_Resurrect_Once472_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj); bool CPlayerSF_ReturnBindPosition474_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_SPDec476_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_STInc_Once478_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_SelfDestruction480_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_SkillContHelpTimeInc_Once482_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_Stun484_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); bool CPlayerSF_TeleportToDestination486_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, bool bStone); bool CPlayerSF_TransDestHP488_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue, char* byRet); bool CPlayerSF_TransMonsterHP490_wrapper(struct CPlayer* _this, struct CCharacter* pDstObj, float fEffectValue); void CPlayerSendData_ChatTrans492_wrapper(struct CPlayer* _this, char byChatType, unsigned int dwSenderSerial, char byRaceCode, bool bFilter, char* pwszMessage, char byPvpGrade, char* pwszSender); void CPlayerSendData_PartyMemberEffect494_wrapper(struct CPlayer* _this, char byAlterCode, uint16_t wEffectCode, char byLv); void CPlayerSendData_PartyMemberFP496_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberHP498_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberInfo500_wrapper(struct CPlayer* _this, uint16_t wDstIndex); void CPlayerSendData_PartyMemberInfoToMembers502_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberLv504_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberMaxHFSP506_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberPos508_wrapper(struct CPlayer* _this); void CPlayerSendData_PartyMemberSP510_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AMPInvenDownloadResult512_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AddBagResult514_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_AddEffect516_wrapper(struct CPlayer* _this, uint16_t wEffectCode, char byLv, uint16_t wDurSec, unsigned int dwPlayerSerial, char* wszPlayerName); void CPlayerSendMsg_AdjustAmountInform518_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial, unsigned int dwDur); void CPlayerSendMsg_AlterBooster520_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterContEffectTime522_wrapper(struct CPlayer* _this, char byContType); void CPlayerSendMsg_AlterEquipSPInform524_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterExpInform526_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterGradeInform528_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterHPInform530_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterItemDurInform532_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wItemSerial, uint64_t dwDur); void CPlayerSendMsg_AlterMaxDP534_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterMoneyInform536_wrapper(struct CPlayer* _this, char byReasonCode); void CPlayerSendMsg_AlterPvPCash538_wrapper(struct CPlayer* _this, int nIOCode); void CPlayerSendMsg_AlterPvPPoint540_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterPvPRank542_wrapper(struct CPlayer* _this, uint16_t wPvpRate, unsigned int dwPvpRank); void CPlayerSendMsg_AlterRegionInform544_wrapper(struct CPlayer* _this, int nRegionIndex); void CPlayerSendMsg_AlterSPInform546_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterTol548_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterTowerHP550_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t wLeftHP); void CPlayerSendMsg_AlterTownOrField552_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AlterUnitBulletInform554_wrapper(struct CPlayer* _this, char byPart, uint16_t wLeftNum); void CPlayerSendMsg_AlterUnitHPInform556_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwGauge); void CPlayerSendMsg_AlterWeaponBulletInform558_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t wLeftNum); void CPlayerSendMsg_Alter_Action_Point560_wrapper(struct CPlayer* _this, char byActCode, unsigned int dwActPoint); void CPlayerSendMsg_AnimusExpInform562_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AnimusFPInform564_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AnimusHPInform566_wrapper(struct CPlayer* _this); void CPlayerSendMsg_AnimusInvenChange568_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_AnimusModeInform570_wrapper(struct CPlayer* _this, char byMode); void CPlayerSendMsg_AnimusRecallResult572_wrapper(struct CPlayer* _this, char byResultCode, uint16_t wLeftFP, struct CAnimus* pNewAnimus); void CPlayerSendMsg_AnimusRecallWaitTimeFree574_wrapper(struct CPlayer* _this, bool bFree); void CPlayerSendMsg_AnimusReturnResult576_wrapper(struct CPlayer* _this, char byRetCode, uint16_t wAnimusItemSerial, char byReturnType); void CPlayerSendMsg_AnimusTargetResult578_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_ApexInform580_wrapper(struct CPlayer* _this, unsigned int dwRecvSize, char* pMsg); void CPlayerSendMsg_AttackResult_Count582_wrapper(struct CPlayer* _this, struct CAttack* pAt); void CPlayerSendMsg_AttackResult_Error584_wrapper(struct CPlayer* _this, int nErrCode); void CPlayerSendMsg_AttackResult_Force586_wrapper(struct CPlayer* _this, struct CAttack* pAt); void CPlayerSendMsg_AttackResult_Gen588_wrapper(struct CPlayer* _this, struct CAttack* pAt, uint16_t wBulletIndex); void CPlayerSendMsg_AttackResult_SelfDestruction590_wrapper(struct CPlayer* _this, struct CAttack* pAt); void CPlayerSendMsg_AttackResult_Siege592_wrapper(struct CPlayer* _this, struct CAttack* pAt, uint16_t wBulletIndex); void CPlayerSendMsg_AttackResult_Skill594_wrapper(struct CPlayer* _this, char byEffectCode, struct CPlayerAttack* pAt, uint16_t wBulletIndex); void CPlayerSendMsg_AttackResult_Unit596_wrapper(struct CPlayer* _this, struct CAttack* pAt, char byWeaponPart, uint16_t wBulletIndex); void CPlayerSendMsg_AwayPartyInvitationQuestion598_wrapper(struct CPlayer* _this, uint16_t wJoinerIndex); void CPlayerSendMsg_AwayPartyRequestResult600_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_BackTowerResult602_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wItemSerial, uint16_t wLeftHP); void CPlayerSendMsg_BackTrapResult604_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_BaseDownloadResult606_wrapper(struct CPlayer* _this); void CPlayerSendMsg_BillingExipreInform608_wrapper(struct CPlayer* _this, char byKind, uint16_t wWaitSec); void CPlayerSendMsg_BillingTypeChangeInform610_wrapper(struct CPlayer* _this, int16_t iType, int lRemainTime, struct _SYSTEMTIME* pstEndDate, char byReason); void CPlayerSendMsg_BreakdownEquipItem612_wrapper(struct CPlayer* _this, char byPartIndex, uint16_t wSerial); void CPlayerSendMsg_BuddhaEventMsg614_wrapper(struct CPlayer* _this, char byErrorCode); void CPlayerSendMsg_BuddyAddAnswerResult616_wrapper(struct CPlayer* _this, char byRetCode, bool bAccept, unsigned int dwAskerSerial, uint16_t wIndex, unsigned int dwSerial, char* pwszCharName); void CPlayerSendMsg_BuddyAddAsk618_wrapper(struct CPlayer* _this, uint16_t wAskerIndex, unsigned int dwAskerSerial, char* pwszAskerName); void CPlayerSendMsg_BuddyAddFail620_wrapper(struct CPlayer* _this, char byRetCode, char* pwszDstName); void CPlayerSendMsg_BuddyDelResult622_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwSerial); void CPlayerSendMsg_BuddyLoginInform624_wrapper(struct CPlayer* _this, unsigned int dwObjSerial, char byMapIndex, char byPosCode); void CPlayerSendMsg_BuddyLogoffInform626_wrapper(struct CPlayer* _this, unsigned int dwObjSerial); void CPlayerSendMsg_BuddyNameReNewal628_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* wszName); void CPlayerSendMsg_BuddyPosInform630_wrapper(struct CPlayer* _this, unsigned int dwDstSerial, char byMapIndex, char byPosCode); void CPlayerSendMsg_BuyCashItemMode632_wrapper(struct CPlayer* _this); void CPlayerSendMsg_BuyItemStoreResult634_wrapper(struct CPlayer* _this, struct CItemStore* pStore, int nOfferNum, struct _buy_offer* pCard, char byErrCode); void CPlayerSendMsg_CancelSuggestResult636_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_CastVoteResult638_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_ChangeClassCommand640_wrapper(struct CPlayer* _this); void CPlayerSendMsg_CharacterRenameCashResult642_wrapper(struct CPlayer* _this, bool bChange, char byErrCode); void CPlayerSendMsg_ChatFarFailure644_wrapper(struct CPlayer* _this, bool bBlock); void CPlayerSendMsg_Circle_DelEffect646_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, char byLv, bool bToOne); void CPlayerSendMsg_ClassSkillResult648_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, uint16_t wSkillIndex); void CPlayerSendMsg_ClearDarkHole650_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_CombineItemExAcceptResult652_wrapper(struct CPlayer* _this, struct _combine_ex_item_accept_result_zocl* pSend); void CPlayerSendMsg_CombineItemExResult654_wrapper(struct CPlayer* _this, struct _combine_ex_item_result_zocl* pSend); void CPlayerSendMsg_CombineItemResult656_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwFee, struct _STORAGE_LIST::_db_con* pNewItem); void CPlayerSendMsg_CombineLendItemResult658_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwFee, struct _STORAGE_LIST::_db_con* pNewItem); void CPlayerSendMsg_CreateTowerResult660_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwTowerObjSerial); void CPlayerSendMsg_CreateTrapResult662_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwTrapObjSerial); void CPlayerSendMsg_CumDownloadResult664_wrapper(struct CPlayer* _this); void CPlayerSendMsg_CuttingCompleteResult666_wrapper(struct CPlayer* _this, char byRet); void CPlayerSendMsg_DTradeAccomplishInform668_wrapper(struct CPlayer* _this, bool bSucc, uint16_t wStartSerial); void CPlayerSendMsg_DTradeAddInform670_wrapper(struct CPlayer* _this, char bySlotIndex, struct _STORAGE_LIST::_db_con* pItem, char byAmount); void CPlayerSendMsg_DTradeAddResult672_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeAnswerResult674_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeAskInform676_wrapper(struct CPlayer* _this, struct CPlayer* pAsker); void CPlayerSendMsg_DTradeAskResult678_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeBetInform680_wrapper(struct CPlayer* _this, char byUnitCode, unsigned int dwAmount); void CPlayerSendMsg_DTradeBetResult682_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeCancleInform684_wrapper(struct CPlayer* _this); void CPlayerSendMsg_DTradeCancleResult686_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeCloseInform688_wrapper(struct CPlayer* _this, char byCloseCode); void CPlayerSendMsg_DTradeDelInform690_wrapper(struct CPlayer* _this, char bySlotIndex); void CPlayerSendMsg_DTradeDelResult692_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeLockInform694_wrapper(struct CPlayer* _this); void CPlayerSendMsg_DTradeLockResult696_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeOKInform698_wrapper(struct CPlayer* _this); void CPlayerSendMsg_DTradeOKResult700_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_DTradeStartInform702_wrapper(struct CPlayer* _this, struct CPlayer* pAsker, struct CPlayer* pAnswer, unsigned int* pdwKey); void CPlayerSendMsg_DTradeUnitAddInform704_wrapper(struct CPlayer* _this, uint16_t wUnitKeySerial, struct _UNIT_DB_BASE::_LIST* pUnitData); void CPlayerSendMsg_DTradeUnitInfoInform706_wrapper(struct CPlayer* _this, char byTradeSlotIndex, struct _UNIT_DB_BASE::_LIST* pUnitData); void CPlayerSendMsg_DamageResult708_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_DarkHoleOpenFail710_wrapper(struct CPlayer* _this, int n, char byErrCode); void CPlayerSendMsg_DarkHoleOpenResult712_wrapper(struct CPlayer* _this, int n, int bPartyOnly, char byErrCode, uint16_t wHoleIndex, unsigned int dwHoleSerial); void CPlayerSendMsg_DarkHoleRewardMessage714_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, unsigned int dwMemberIndex, int isRewarded); void CPlayerSendMsg_DelEffect716_wrapper(struct CPlayer* _this, char byEffectCode, uint16_t wEffectIndex, char byLv); void CPlayerSendMsg_DeleteStorageInform718_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial); void CPlayerSendMsg_Destroy720_wrapper(struct CPlayer* _this); void CPlayerSendMsg_Die722_wrapper(struct CPlayer* _this); void CPlayerSendMsg_EconomyHistoryInform724_wrapper(struct CPlayer* _this); void CPlayerSendMsg_EconomyRateInform726_wrapper(struct CPlayer* _this, bool bStart); void CPlayerSendMsg_EmbellishResult728_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_EnterDarkHole730_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwHoleSerial); void CPlayerSendMsg_EquipItemLevelLimit732_wrapper(struct CPlayer* _this, int nCurPlayerLv); void CPlayerSendMsg_EquipPartChange734_wrapper(struct CPlayer* _this, char byPart); void CPlayerSendMsg_EquipPartResult736_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_ExchangeItemResult738_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pNewItem); void CPlayerSendMsg_ExchangeLendItemResult740_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pNewItem); void CPlayerSendMsg_ExchangeMoneyResult742_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_ExitWorldResult744_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_ExtTrunkExtendResult746_wrapper(struct CPlayer* _this, char byRetCode, char bySlotNum, char byLackSlotNum); void CPlayerSendMsg_FanfareItem748_wrapper(struct CPlayer* _this, char byGetType, struct _STORAGE_LIST::_db_con* pItem, struct CItemBox* pItemBox); void CPlayerSendMsg_FcitemInform750_wrapper(struct CPlayer* _this, uint16_t wItemSerial, unsigned int dwNewStat); void CPlayerSendMsg_FixPosition752_wrapper(struct CPlayer* _this, int n); void CPlayerSendMsg_ForceDownloadResult754_wrapper(struct CPlayer* _this); void CPlayerSendMsg_ForceInvenChange756_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_ForceResult758_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, struct _STORAGE_LIST::_db_con* pForceItem, int nSFLv); void CPlayerSendMsg_GM_Greeting760_wrapper(struct CPlayer* _this, char* wszGMName, char* wszMsg); void CPlayerSendMsg_GUILD_Greeting762_wrapper(struct CPlayer* _this, char* wszName, char* wszMsg); void CPlayerSendMsg_GestureInform764_wrapper(struct CPlayer* _this, char byGestureType); void CPlayerSendMsg_GiveupDarkHole766_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_GotoBasePortalResult768_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_GotoRecallResult770_wrapper(struct CPlayer* _this, char byErrCode, char byMapCode, float* pfStartPos, char byMapInType); void CPlayerSendMsg_GroupTargetInform772_wrapper(struct CPlayer* _this, char byGroupType, char* pwszName); void CPlayerSendMsg_GuildEstablishFail774_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_GuildForceLeaveBoradori776_wrapper(struct CPlayer* _this); void CPlayerSendMsg_GuildJoinAcceptFail778_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwApplierSerial); void CPlayerSendMsg_GuildJoinApplyCancelResult780_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_GuildJoinApplyRejectInform782_wrapper(struct CPlayer* _this); void CPlayerSendMsg_GuildJoinApplyResult784_wrapper(struct CPlayer* _this, char byRetCode, struct CGuild* pApplyGuild); void CPlayerSendMsg_GuildJoinOtherInform786_wrapper(struct CPlayer* _this); void CPlayerSendMsg_GuildManageResult788_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_GuildMasterEffect790_wrapper(struct CPlayer* _this, char byState, char byGrade, char byEffSubAttack, char byEffSubDefence, char byEffAddAttack, char byEffAddDefence); void CPlayerSendMsg_GuildPushMoneyResult792_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_GuildRoomEnterResult794_wrapper(struct CPlayer* _this, char byRetCode, char bySubRetCode, char byMapIndex, uint16_t wMapLayer, float* pPos, int tt); void CPlayerSendMsg_GuildRoomOutResult796_wrapper(struct CPlayer* _this, char byRetCode, char byMapIndex, uint16_t wMapLayer, float* pPos); void CPlayerSendMsg_GuildRoomRentResult798_wrapper(struct CPlayer* _this, char byRetCode, char bySubRetCode, char byRoomType); void CPlayerSendMsg_GuildRoomRestTimeResult800_wrapper(struct CPlayer* _this); void CPlayerSendMsg_GuildSelfLeaveResult802_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_GuildSetHonorResult804_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_HSKQuestActCum806_wrapper(struct CPlayer* _this); void CPlayerSendMsg_HSKQuestSucc808_wrapper(struct CPlayer* _this, char byQuestCode, bool bSucc); void CPlayerSendMsg_HonorGuildMark810_wrapper(struct CPlayer* _this, char byRank); void CPlayerSendMsg_InformTaxIncome812_wrapper(struct CPlayer* _this, char byRet, unsigned int dwComm, char* pwszDate); void CPlayerSendMsg_Init_Action_Point814_wrapper(struct CPlayer* _this); void CPlayerSendMsg_InsertItemInform816_wrapper(struct CPlayer* _this, char byStorageCode, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_InsertNewQuest818_wrapper(struct CPlayer* _this, char bySlotIndex, struct _QUEST_DB_BASE::_LIST* pQuestDB); void CPlayerSendMsg_InsertNextQuest820_wrapper(struct CPlayer* _this, char bySlotIndex, struct _QUEST_DB_BASE::_LIST* pQuestDB); void CPlayerSendMsg_InsertQuestFailure822_wrapper(struct CPlayer* _this, char byEventType, unsigned int dwEventIndex, char byEventNodeIndex); void CPlayerSendMsg_InsertQuestItemInform824_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_InvenDownloadResult826_wrapper(struct CPlayer* _this); void CPlayerSendMsg_ItemDowngrade828_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_ItemStorageRefresh830_wrapper(struct CPlayer* _this, char byStorageCode); void CPlayerSendMsg_ItemUpgrade832_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_JadeEffectErr834_wrapper(struct CPlayer* _this, char byErrorCode); void CPlayerSendMsg_LendItemTimeExpired836_wrapper(struct CPlayer* _this, char byStorageCode, uint16_t wSerial); void CPlayerSendMsg_Level838_wrapper(struct CPlayer* _this, int nLevel); void CPlayerSendMsg_LinkBoardDownloadResult840_wrapper(struct CPlayer* _this); void CPlayerSendMsg_MacroRequest842_wrapper(struct CPlayer* _this); void CPlayerSendMsg_MadeTrapNumInform844_wrapper(struct CPlayer* _this, char byNum); void CPlayerSendMsg_MakeItemCheatSendButtonEnable846_wrapper(struct CPlayer* _this, bool bEnableSendButton); void CPlayerSendMsg_MakeItemResult848_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_MapEnvInform850_wrapper(struct CPlayer* _this, char byMapCode, unsigned int dwMapEnvCode); void CPlayerSendMsg_MapOut852_wrapper(struct CPlayer* _this, char byMapOutCode, char byNextMapCode); void CPlayerSendMsg_MaxHFSP854_wrapper(struct CPlayer* _this); void CPlayerSendMsg_MaxPvpPointInform856_wrapper(struct CPlayer* _this, int nMax); void CPlayerSendMsg_MineCancle858_wrapper(struct CPlayer* _this); void CPlayerSendMsg_MineCompleteResult860_wrapper(struct CPlayer* _this, char byErrCode, char byNewOreIndex, uint16_t dwOreSerial, char byOreDur, uint16_t dwBatteryLeftDurPoint); void CPlayerSendMsg_MineStartResult862_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_MonsterAggroData864_wrapper(struct CPlayer* _this, struct CCharacter* pCharacter); void CPlayerSendMsg_MoveError866_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_MoveNext868_wrapper(struct CPlayer* _this, bool bOtherSend); void CPlayerSendMsg_MovePortal870_wrapper(struct CPlayer* _this, char byMapIndex, float* pfStartPos, char byZoneCode); void CPlayerSendMsg_MoveToOwnStoneMapInform874_wrapper(struct CPlayer* _this, char byStoneMapMoveInfo); void CPlayerSendMsg_MoveToOwnStoneMapResult876_wrapper(struct CPlayer* _this, char byRetCode, char byMapIndex, float* pos); void CPlayerSendMsg_NPCLinkItemCheckResult878_wrapper(struct CPlayer* _this, char byResCode, struct _STORAGE_POS_INDIV* pStorage); void CPlayerSendMsg_NewMovePotionResult880_wrapper(struct CPlayer* _this); void CPlayerSendMsg_NewViewOther882_wrapper(struct CPlayer* _this, char byViewType); void CPlayerSendMsg_NotifyEffectForGetItem884_wrapper(struct CPlayer* _this, char byBoxType, unsigned int dwCharSerial, char* szCharName, struct _STORAGE_LIST::_db_con* pItem, bool bCircle); void CPlayerSendMsg_NotifyGetExpInfo886_wrapper(struct CPlayer* _this, long double dOldExp, long double dAlterExp, long double dCurExp); void CPlayerSendMsg_Notify_ExceptFromRaceRanking888_wrapper(struct CPlayer* _this, int bExcepted); void CPlayerSendMsg_Notify_Get_Golden_Box890_wrapper(struct CPlayer* _this, char byBoxType, unsigned int dwCharSerial, char* szCharName, struct _STORAGE_LIST::_db_con* pItem, bool bCircle); void CPlayerSendMsg_Notify_Gravity_Stone_Owner_Die892_wrapper(struct CPlayer* _this); void CPlayerSendMsg_Notify_Me_Get_Golden_Box894_wrapper(struct CPlayer* _this, char byBoxType, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_NpcQuestHistoryInform896_wrapper(struct CPlayer* _this, char bySlotIndex); void CPlayerSendMsg_NpcQuestListResult898_wrapper(struct CPlayer* _this, struct _NPCQuestIndexTempData* pQuestIndexData); void CPlayerSendMsg_OffPartResult900_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_OfferSuggestResult902_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_OreCuttingResult904_wrapper(struct CPlayer* _this, char byErrCode, char byLeftOreNum, unsigned int dwConsumDalant); void CPlayerSendMsg_OreIntoBagResult906_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wNewSerial, char byLendType, unsigned int dwLendTime); void CPlayerSendMsg_OreTransferCount908_wrapper(struct CPlayer* _this); void CPlayerSendMsg_OtherShapeAll910_wrapper(struct CPlayer* _this, struct CPlayer* pDst); void CPlayerSendMsg_OtherShapeError912_wrapper(struct CPlayer* _this, struct CPlayer* pDst, char byErrCode); void CPlayerSendMsg_OtherShapePart914_wrapper(struct CPlayer* _this, struct CPlayer* pDst); void CPlayerSendMsg_OtherShapePartEx_CashChange916_wrapper(struct CPlayer* _this, struct CPlayer* pDst, CPlayer::CashChangeStateFlag ServerData, CPlayer::CashChangeStateFlag ClinetData); void CPlayerSendMsg_PartyAlterLootShareResult918_wrapper(struct CPlayer* _this, char byLootShareMode); void CPlayerSendMsg_PartyDisjointResult920_wrapper(struct CPlayer* _this, char bSuccess); void CPlayerSendMsg_PartyJoinApplicationQuestion922_wrapper(struct CPlayer* _this, struct CPlayer* pJoiner); void CPlayerSendMsg_PartyJoinFailLevel924_wrapper(struct CPlayer* _this); void CPlayerSendMsg_PartyJoinInvitationQuestion926_wrapper(struct CPlayer* _this, uint16_t wJoinerIndex); void CPlayerSendMsg_PartyJoinJoinerResult928_wrapper(struct CPlayer* _this); void CPlayerSendMsg_PartyJoinMemberResult930_wrapper(struct CPlayer* _this, struct CPartyPlayer* pJoiner, char byLootShareMode); void CPlayerSendMsg_PartyLeaveCompulsionResult932_wrapper(struct CPlayer* _this, struct CPartyPlayer* pLeaver); void CPlayerSendMsg_PartyLeaveSelfResult934_wrapper(struct CPlayer* _this, struct CPartyPlayer* pLeaver, bool bWorldExit); void CPlayerSendMsg_PartyLockResult936_wrapper(struct CPlayer* _this, char byRet); void CPlayerSendMsg_PartyLootItemInform938_wrapper(struct CPlayer* _this, unsigned int dwTakerSerial, char byTableCode, uint16_t wItemIndex, char byNum); void CPlayerSendMsg_PartySuccessResult940_wrapper(struct CPlayer* _this, struct CPartyPlayer* pSuccessor); void CPlayerSendMsg_PcRoomCharClass942_wrapper(struct CPlayer* _this, unsigned int dwPcRoomClassIndex); void CPlayerSendMsg_PcRoomError944_wrapper(struct CPlayer* _this, char byErrorCode); void CPlayerSendMsg_PostContent946_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial, char* wszContent, char byTableCode, uint16_t wItemIndex, uint64_t dwDur, unsigned int dwLv, unsigned int dwGold); void CPlayerSendMsg_PostDelete948_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial); void CPlayerSendMsg_PostDelivery950_wrapper(struct CPlayer* _this, char byIndex, unsigned int dwPostSerial, char* wszSendName, char* wszTitle, bool bItem, bool bGold, char byState); void CPlayerSendMsg_PostItemGold952_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_PostReturn954_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial, char* wszRecvName, char* wszTitle, char* wszContent, char byTableCode, uint16_t wItemIndex, uint64_t dwDur, unsigned int dwLv, unsigned int dwGold); void CPlayerSendMsg_PostReturnConfirm956_wrapper(struct CPlayer* _this, char byErrCode, unsigned int dwPostSerial); void CPlayerSendMsg_PostSendReply958_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_PotionDelayTime960_wrapper(struct CPlayer* _this, unsigned int* pdwPotionNextUseTime, unsigned int dwCurTime); void CPlayerSendMsg_PotionDivision962_wrapper(struct CPlayer* _this, uint16_t wSerial, char byParentAmount, uint16_t wChildSerial, char byChildAmount, int nRet); void CPlayerSendMsg_PotionSeparation964_wrapper(struct CPlayer* _this, uint16_t wParentSerial, char byParentAmount, uint16_t wChildSerial, char byChildAmount, int nRet); void CPlayerSendMsg_PremiumCashItemUse966_wrapper(struct CPlayer* _this, uint16_t wSerial); void CPlayerSendMsg_ProposeVoteResult968_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_PvpRankListVersionUp970_wrapper(struct CPlayer* _this, char byVersion); void CPlayerSendMsg_QuestComplete972_wrapper(struct CPlayer* _this, char byQuestDBSlot); void CPlayerSendMsg_QuestDownloadResult974_wrapper(struct CPlayer* _this); void CPlayerSendMsg_QuestFailure976_wrapper(struct CPlayer* _this, char byFailCode, char byQuestDBSlot); void CPlayerSendMsg_QuestGiveUpResult978_wrapper(struct CPlayer* _this, char byReturnSlot); void CPlayerSendMsg_QuestHistoryDownloadResult980_wrapper(struct CPlayer* _this); void CPlayerSendMsg_QuestProcess982_wrapper(struct CPlayer* _this, char byQuestDBSlot, char byActIndex, uint16_t wCount); void CPlayerSendMsg_RACE_Greeting984_wrapper(struct CPlayer* _this, char* wszBossName, char* wszMsg); void CPlayerSendMsg_RaceBattlePenelty986_wrapper(struct CPlayer* _this, int nAlterPoint, char byAlterType); void CPlayerSendMsg_RaceBossCryMsg988_wrapper(struct CPlayer* _this); void CPlayerSendMsg_RaceTopInform990_wrapper(struct CPlayer* _this, bool bTop); void CPlayerSendMsg_RadarCharSearchResult992_wrapper(struct CPlayer* _this); void CPlayerSendMsg_RadarDelayTime994_wrapper(struct CPlayer* _this, unsigned int dwDelay); void CPlayerSendMsg_ReEnterAsk996_wrapper(struct CPlayer* _this, uint16_t wChannelIndex, unsigned int dwChannelSerial); void CPlayerSendMsg_ReEnterDarkHoleResult998_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_RealMovePoint1000_wrapper(struct CPlayer* _this, int n); void CPlayerSendMsg_Recover1002_wrapper(struct CPlayer* _this); void CPlayerSendMsg_RecvHSKQuest1004_wrapper(struct CPlayer* _this); void CPlayerSendMsg_RefeshGroupTargetPosition1006_wrapper(struct CPlayer* _this, char byGroupType); void CPlayerSendMsg_RegistBindResult1008_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_ReleaseGroupTargetObjectResult1010_wrapper(struct CPlayer* _this, char byGroupType); void CPlayerSendMsg_ReleaseSiegeModeResult1012_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_RemainOreRate1014_wrapper(struct CPlayer* _this); void CPlayerSendMsg_RemainTimeInform1016_wrapper(struct CPlayer* _this, int16_t iType, int lRemainTime, struct _SYSTEMTIME* pstEndDate); void CPlayerSendMsg_ResDivision1018_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pTargetOre); void CPlayerSendMsg_ResSeparation1020_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pNewOre); void CPlayerSendMsg_ResultChangeTaxRate1022_wrapper(struct CPlayer* _this, char byRetCode, char byNextTax); void CPlayerSendMsg_ResultNpcQuest1024_wrapper(struct CPlayer* _this, bool bSucc); void CPlayerSendMsg_Resurrect1026_wrapper(struct CPlayer* _this, char byRet, bool bQuickPotion); void CPlayerSendMsg_ResurrectInform1028_wrapper(struct CPlayer* _this); void CPlayerSendMsg_Revival1030_wrapper(struct CPlayer* _this, char byRet, bool bEquialZone); void CPlayerSendMsg_RevivalOfJade1032_wrapper(struct CPlayer* _this, uint16_t wSuccRate); void CPlayerSendMsg_RewardAddItem1034_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, char byReason); void CPlayerSendMsg_SFDelayRequest1036_wrapper(struct CPlayer* _this); void CPlayerSendMsg_SelectClassResult1038_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSelClassIndex); void CPlayerSendMsg_SelectQuestReward1040_wrapper(struct CPlayer* _this, char byQuestDBSlot); void CPlayerSendMsg_SelectWaitedQuest1042_wrapper(struct CPlayer* _this, char byEventType, unsigned int dwEventIndex, char byEventNodeIndex); void CPlayerSendMsg_SellItemStoreResult1044_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byErrCode); void CPlayerSendMsg_SetDPInform1046_wrapper(struct CPlayer* _this); void CPlayerSendMsg_SetFPInform1048_wrapper(struct CPlayer* _this); void CPlayerSendMsg_SetGroupMapPoint1050_wrapper(struct CPlayer* _this, char byRetCode, char byGroupType, char byMapCode, float* pzTar, char byRemain); void CPlayerSendMsg_SetGroupTargetObjectResult1052_wrapper(struct CPlayer* _this, char byRetCode, char byGroupType); void CPlayerSendMsg_SetHPInform1054_wrapper(struct CPlayer* _this); void CPlayerSendMsg_SetItemCheckResult1056_wrapper(struct CPlayer* _this, char byResult, unsigned int dwSetItem, char bySetEffectNum); void CPlayerSendMsg_SetSPInform1058_wrapper(struct CPlayer* _this); void CPlayerSendMsg_SetTargetObjectResult1060_wrapper(struct CPlayer* _this, char byRetCode, bool bForce); void CPlayerSendMsg_SkillResult1062_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, char bySkillIndex, int nSFLv); void CPlayerSendMsg_SpecialDownloadResult1064_wrapper(struct CPlayer* _this); void CPlayerSendMsg_StartContSF1066_wrapper(struct CPlayer* _this, struct _sf_continous* pCont); void CPlayerSendMsg_StartNewPos1068_wrapper(struct CPlayer* _this, char byMapInMode); void CPlayerSendMsg_StartShopping1070_wrapper(struct CPlayer* _this); void CPlayerSendMsg_StatInform1072_wrapper(struct CPlayer* _this, char byStatIndex, unsigned int dwNewStat, char byReason); void CPlayerSendMsg_StateInform1074_wrapper(struct CPlayer* _this, uint64_t dwStateFlag); void CPlayerSendMsg_Stop1076_wrapper(struct CPlayer* _this, bool bAll); void CPlayerSendMsg_StoreLimitItemAmountInfo1078_wrapper(struct CPlayer* _this, unsigned int dwStoreIndex, struct _limit_amount_info* pAmountInfo); void CPlayerSendMsg_StoreListResult1080_wrapper(struct CPlayer* _this); void CPlayerSendMsg_TLStatusInfo1082_wrapper(struct CPlayer* _this, unsigned int dwFatigue, char wStatus); void CPlayerSendMsg_TLStatusPenalty1084_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_TakeAddResult1086_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_TakeNewResult1088_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pItem); void CPlayerSendMsg_TalikCrystalExchangeResult1090_wrapper(struct CPlayer* _this, char byRet, char byExchangeNum, struct _STORAGE_LIST::_db_con* pNewItem); void CPlayerSendMsg_TargetObjectHPInform1092_wrapper(struct CPlayer* _this); void CPlayerSendMsg_TeleportError1094_wrapper(struct CPlayer* _this, char byErrorCode, unsigned int dwMapIndex); void CPlayerSendMsg_TestAttackResult1096_wrapper(struct CPlayer* _this, char byEffectCode, char byEffectIndex, uint16_t wBulletItemIndex, char byEffectLv, char byWeaponPart, int16_t* pzTar); void CPlayerSendMsg_ThrowSkillResult1098_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, char bySkillIndex); void CPlayerSendMsg_ThrowStorageResult1100_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_ThrowUnitResult1102_wrapper(struct CPlayer* _this, char byErrCode, struct _CHRID* pidDst, uint16_t wBulletIndex); void CPlayerSendMsg_TowerContinue1104_wrapper(struct CPlayer* _this, uint16_t wItemSerial, struct CGuardTower* pTwr); void CPlayerSendMsg_TransShipRenewTicketResult1106_wrapper(struct CPlayer* _this, char byErrCode); void CPlayerSendMsg_TransformSiegeModeResult1108_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_TrunkChangPasswdResult1110_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_TrunkDownloadResult1112_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_TrunkEstResult1114_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwLeftDalant); void CPlayerSendMsg_TrunkExtendResult1116_wrapper(struct CPlayer* _this, char byRetCode, char bySlotNum, unsigned int dwLeftDalant, unsigned int dwConsumDalant); void CPlayerSendMsg_TrunkHintAnswerResult1118_wrapper(struct CPlayer* _this, char byRetCode, char* pwszPassword); void CPlayerSendMsg_TrunkIoMoneyResult1120_wrapper(struct CPlayer* _this, char byRetCode, long double dTrunkDalant, long double dTrunkGold, unsigned int dwDalant, unsigned int dwGold, unsigned int dwFeeDalant); void CPlayerSendMsg_TrunkIoResult1122_wrapper(struct CPlayer* _this, char byCase, char byRetCode, unsigned int dwLeftDalant, unsigned int dwConsumDanlant); void CPlayerSendMsg_TrunkPotionDivision1124_wrapper(struct CPlayer* _this, uint16_t wSerial, uint16_t wParentAmount, uint16_t wChildSerial, uint16_t wChildAmount, int nRet); void CPlayerSendMsg_TrunkPwHintIndexResult1126_wrapper(struct CPlayer* _this, char byRetCode, char byHintIndex); void CPlayerSendMsg_TrunkResDivision1128_wrapper(struct CPlayer* _this, char byErrCode, struct _STORAGE_LIST::_db_con* pStartOre, struct _STORAGE_LIST::_db_con* pTargetOre); void CPlayerSendMsg_UILock_FindPW_Result1130_wrapper(struct CPlayer* _this, char byRet, char* uszUILockPW, char byFindPassFailCount); void CPlayerSendMsg_UILock_Init_Request_ToAccount1132_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* uszUILockPW, uint16_t wUserIndex, char byHintIndex, char* uszHintAnswer); void CPlayerSendMsg_UILock_Init_Result1134_wrapper(struct CPlayer* _this, char byRet); void CPlayerSendMsg_UILock_Login_Result1136_wrapper(struct CPlayer* _this, char byRet, char byFailCount); void CPlayerSendMsg_UILock_Update_Request_ToAccount1138_wrapper(struct CPlayer* _this, unsigned int dwSerial, char* uszUILockPW, uint16_t wUserIndex, char byHintIndex, char* uszHintAnswer); void CPlayerSendMsg_UILock_Update_Result1140_wrapper(struct CPlayer* _this, char byRet); void CPlayerSendMsg_UnitAlterFeeInform1142_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwPullingFee); void CPlayerSendMsg_UnitBulletFillResult1144_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, uint16_t* pwBulletIndex, unsigned int* pdwConsumMoney); void CPlayerSendMsg_UnitBulletReplaceResult1146_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_UnitDeliveryResult1148_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, unsigned int dwParkingUnitSerial, unsigned int dwPayDalant); void CPlayerSendMsg_UnitDestroy1150_wrapper(struct CPlayer* _this, char bySlotIndex); void CPlayerSendMsg_UnitForceReturnInform1152_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwDebt); void CPlayerSendMsg_UnitFrameBuyResult1154_wrapper(struct CPlayer* _this, char byRetCode, char byFrameCode, char byUnitSlotIndex, uint16_t wKeyIndex, uint16_t wKeySerial, unsigned int* pdwConsumMoney); void CPlayerSendMsg_UnitFrameRepairResult1156_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, unsigned int dwNewGauge, unsigned int dwConsumDalant); void CPlayerSendMsg_UnitLeaveResult1158_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_UnitPackFillResult1160_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, char byFillNum, struct _unit_pack_fill_request_clzo::__list* pList, unsigned int* pdwConsumMoney); void CPlayerSendMsg_UnitPartTuningResult1162_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, int* pnCost); void CPlayerSendMsg_UnitReturnResult1164_wrapper(struct CPlayer* _this, char byRetCode, unsigned int dwPayDalant); void CPlayerSendMsg_UnitRideChange1166_wrapper(struct CPlayer* _this, bool bTake, struct CParkingUnit* pUnit); void CPlayerSendMsg_UnitSellResult1168_wrapper(struct CPlayer* _this, char byRetCode, char bySlotIndex, uint16_t wKeySerial, int nAddMoney, unsigned int dwTotalNonpay, unsigned int dwSumDalant, unsigned int dwSumGold); void CPlayerSendMsg_UnitTakeResult1170_wrapper(struct CPlayer* _this, char byRetCode); void CPlayerSendMsg_UpdateTLStatusInfo1172_wrapper(struct CPlayer* _this, unsigned int dwFatigue, char wStatus); void CPlayerSendMsg_UsPotionResultOther1174_wrapper(struct CPlayer* _this, char byRetcode, uint16_t wPotionIndex, struct CPlayer* pUsePlayer, bool bCircle); void CPlayerSendMsg_UseJadeResult1176_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wItemSerial); void CPlayerSendMsg_UsePotionResult1178_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSerial, char byLeftNum); void CPlayerSendMsg_UseRadarResult1180_wrapper(struct CPlayer* _this, char byErrCode, uint16_t wSerial, unsigned int dwDelay); void CPlayerSendMsg_VoteResult1182_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey, char byRetCode); void CPlayerSendTargetMonsterSFContInfo1184_wrapper(struct CPlayer* _this); void CPlayerSendTargetPlayerDamageContInfo1186_wrapper(struct CPlayer* _this); void CPlayerSenseState1188_wrapper(struct CPlayer* _this); void CPlayerSetAttackPart1190_wrapper(struct CPlayer* _this, int nAttactPart); void CPlayerSetBattleMode1192_wrapper(struct CPlayer* _this, bool bAttack); void CPlayerSetBindDummy1194_wrapper(struct CPlayer* _this, struct _dummy_position* pDummy); void CPlayerSetBindMapData1196_wrapper(struct CPlayer* _this, struct CMapData* pMapData); bool CPlayerSetBindPosition1198_wrapper(struct CPlayer* _this, struct CMapData* pMap, struct _dummy_position* pDummy); void CPlayerSetCashAmount1200_wrapper(struct CPlayer* _this, int nAmount); void CPlayerSetCntEnable1202_wrapper(struct CPlayer* _this, bool bSet); bool CPlayerSetDP1204_wrapper(struct CPlayer* _this, int nDP, bool bOver); int CPlayerSetDamage1206_wrapper(struct CPlayer* _this, int nDamage, struct CCharacter* pDst, int nDstLv, bool bCrt, int nAttackType, unsigned int dwAttackSerial, bool bJadeReturn); void CPlayerSetEffectEquipCode1208_wrapper(struct CPlayer* _this, char byStorageCode, char bySlotIndex, char byCode); void CPlayerSetEquipEffect1210_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_storage_con* pItem, bool bEquip); void CPlayerSetEquipJadeEffect1212_wrapper(struct CPlayer* _this, int nParam, float fCurVal, bool bAdd); bool CPlayerSetFP1214_wrapper(struct CPlayer* _this, int nFP, bool bOver); void CPlayerSetGauge1216_wrapper(struct CPlayer* _this, int nParamCode, int nValue, bool bOver); void CPlayerSetGrade1218_wrapper(struct CPlayer* _this, char byGrade); bool CPlayerSetHP1220_wrapper(struct CPlayer* _this, int nHP, bool bOver); void CPlayerSetHaveEffect1222_wrapper(struct CPlayer* _this, bool bLogin); void CPlayerSetHaveEffectUseTime1224_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bAdd); void CPlayerSetLastAttBuff1226_wrapper(struct CPlayer* _this, bool bSet); void CPlayerSetLevel1228_wrapper(struct CPlayer* _this, char byNewLevel); void CPlayerSetLevelD1230_wrapper(struct CPlayer* _this, char byDownLevel); void CPlayerSetMstHaveEffect1232_wrapper(struct CPlayer* _this, struct _ResourceItem_fld* pFld, struct _STORAGE_LIST::_db_con* pItem, bool bAdd, int nAlter); void CPlayerSetMstPt1234_wrapper(struct CPlayer* _this, int nMstCode, float fVal, bool bAdd, int nWpType); void CPlayerSetPotionActDelay1236_wrapper(struct CPlayer* _this, char byPotionClass, unsigned int dwCurrTime, unsigned int dwActDelay); void CPlayerSetPvpPointLeak1238_wrapper(struct CPlayer* _this, long double dValue); void CPlayerSetRankRate1240_wrapper(struct CPlayer* _this, uint16_t wRankRate, unsigned int dwRank); bool CPlayerSetSP1242_wrapper(struct CPlayer* _this, int nSP, bool bOver); void CPlayerSetShapeAllBuffer1244_wrapper(struct CPlayer* _this); void CPlayerSetSiege1246_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pSiegeItem); void CPlayerSetStateFlag1248_wrapper(struct CPlayer* _this); void CPlayerSetStaticMember1250_wrapper(); bool CPlayerSetTarPos1252_wrapper(struct CPlayer* _this, float* fTarPos, bool bColl); void CPlayerSetUseReleaseRaceBuffPotion1254_wrapper(struct CPlayer* _this); void CPlayerSetVote1256_wrapper(struct CPlayer* _this, int nSerial); void CPlayerSortPost1258_wrapper(struct CPlayer* _this, int nNumber); void CPlayerSubActPoint1260_wrapper(struct CPlayer* _this, char byCode, unsigned int dwSub); void CPlayerSubDalant1262_wrapper(struct CPlayer* _this, unsigned int dwSub); void CPlayerSubGold1264_wrapper(struct CPlayer* _this, unsigned int dwSub); void CPlayerSubPoint1266_wrapper(struct CPlayer* _this, unsigned int dwSub); unsigned int CPlayerSumMinuteBetween1268_wrapper(struct CPlayer* _this, struct _SYSTEMTIME* tmLast, struct _SYSTEMTIME* tmLocal); unsigned int CPlayerSumMinuteOne1270_wrapper(struct CPlayer* _this, struct _SYSTEMTIME* tm); void CPlayerTakeGravityStone1272_wrapper(struct CPlayer* _this); void CPlayerUpdateAuraSFCont1274_wrapper(struct CPlayer* _this); void CPlayerUpdateChaosModeState1276_wrapper(struct CPlayer* _this, unsigned int dwCurTime); bool CPlayerUpdateDelPost1278_wrapper(struct CPlayer* _this, unsigned int dwPostSerial, int nIndex); void CPlayerUpdateLastCriTicket1280_wrapper(struct CPlayer* _this, uint16_t byCurrentYear, char byCurrentMonth, char byCurrentDay, char byCurrentHour, char byNumOfTime); void CPlayerUpdateLastMetalTicket1282_wrapper(struct CPlayer* _this, uint16_t byCurrentYear, char byCurrentMonth, char byCurrentDay, char byCurrentHour, char byNumOfTime); void CPlayerUpdatePost1284_wrapper(struct CPlayer* _this, unsigned int dwIndex); void CPlayerUpdatePostAddLog1286_wrapper(struct CPlayer* _this, unsigned int dwIndex, bool bLog, int nItemKey); void CPlayerUpdatePvpOrderView1288_wrapper(struct CPlayer* _this, int64_t tCurTime); void CPlayerUpdatePvpPointLimiter1290_wrapper(struct CPlayer* _this, int64_t tCurTime); void CPlayerUpdateReturnPost1292_wrapper(struct CPlayer* _this, unsigned int dwSerial); void CPlayerUpdateVisualVer1294_wrapper(struct CPlayer* _this, CPlayer::CashChangeStateFlag byChangeFlagMask); bool CPlayerUpdate_GoldPoint1296_wrapper(struct CPlayer* _this, unsigned int dwPoint); void CPlayerUpdatedMasteryWriteHistory1298_wrapper(struct CPlayer* _this); bool CPlayerWPActiveForce1300_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int nDamagedObjNum, struct _force_fld* pForceFld); bool CPlayerWPActiveSkill1302_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int nDamagedObjNum, struct _skill_fld* pSkillFld, int nEffectCode); bool CPlayerWeaponSFActive1304_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, int* nShotNum, uint16_t wBulletSerial); void CPlayer_AnimusReturn1306_wrapper(struct CPlayer* _this, char byReturnType); int CPlayer_CalcMaxFP1308_wrapper(struct CPlayer* _this); int CPlayer_CalcMaxHP1310_wrapper(struct CPlayer* _this); int CPlayer_CalcMaxSP1312_wrapper(struct CPlayer* _this); void CPlayer_CheckForcePullUnit1314_wrapper(struct CPlayer* _this); uint16_t CPlayer_DeleteUnitKey1316_wrapper(struct CPlayer* _this, char bySlotIndex); struct _ITEM_EFFECT* CPlayer_GetItemEffect1318_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem); char CPlayer_GetPartyMemberInCircle1320_wrapper(struct CPlayer* _this, struct CPlayer** out_ppMember, int nMax, bool bOne); bool CPlayer_LockUnitKey1322_wrapper(struct CPlayer* _this, char bySlotIndex, bool bLock); struct _Quest_fld* CPlayer_Reward_Quest1324_wrapper(struct CPlayer* _this, struct _Quest_fld* pQuestFld, char byRewardItemIndex); void CPlayer_TowerAllReturn1326_wrapper(struct CPlayer* _this, char byDestroyType, bool bForceReturn); void CPlayer_TowerDestroy1328_wrapper(struct CPlayer* _this, struct CGuardTower* pTowerObj); uint16_t CPlayer_TowerReturn1330_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pTowerItem); void CPlayer_TrapDestroy1332_wrapper(struct CPlayer* _this, struct CTrap* pTrap, char byDestroyCode); void CPlayer_TrapReturn1334_wrapper(struct CPlayer* _this, struct CTrap* pTrap, uint16_t wAddSerial); void CPlayer_UnitDestroy1336_wrapper(struct CPlayer* _this, char byUnitSlot); void CPlayer_UpdateUnitDebt1338_wrapper(struct CPlayer* _this, char bySlotIndex, unsigned int dwPull); void CPlayer_check_dst_param_after_attack1340_wrapper(struct CPlayer* _this, int nTotalDam, struct CCharacter* pTarget); bool CPlayer_check_embel_part1342_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pFixingItem); bool CPlayer_check_equip_part1344_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pFixingItem); int CPlayer_check_equipmastery_lim1346_wrapper(struct CPlayer* _this, int EquipMasteryCode); int CPlayer_check_exp_after_attack1348_wrapper(struct CPlayer* _this, int nDamagedObjNum, struct _be_damaged_char* pList, struct CPartyModeKillMonsterExpNotify* kPartyExpNotify); void CPlayer_check_guild_target_object1350_wrapper(struct CPlayer* _this); void CPlayer_check_hp_send_party1352_wrapper(struct CPlayer* _this); unsigned int CPlayer_check_mastery_cum_lim1354_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex); unsigned int CPlayer_check_mastery_lim1356_wrapper(struct CPlayer* _this, char byMasteryClass, char byIndex); void CPlayer_check_party_target_object1358_wrapper(struct CPlayer* _this); void CPlayer_check_race_target_object1360_wrapper(struct CPlayer* _this); void CPlayer_check_target_object1362_wrapper(struct CPlayer* _this); int CPlayer_pre_check_force_attack1364_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfTarPos, uint16_t wForceItemSerial, struct _force_fld** ppForceFld, struct _STORAGE_LIST::_db_con** ppForceItem, uint16_t* pdwDecPoint, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt); int CPlayer_pre_check_in_guild_battle1366_wrapper(struct CPlayer* _this, struct CCharacter* pDst); bool CPlayer_pre_check_in_guild_battle_race1368_wrapper(struct CPlayer* _this, struct CCharacter* pDst, bool bEqueal); int CPlayer_pre_check_normal_attack1370_wrapper(struct CPlayer* _this, struct CCharacter* pDst, uint16_t wBulletSerial, bool bCount, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt); int CPlayer_pre_check_siege_attack1372_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBulletProp, struct _BulletItem_fld** ppfldEffBullet); int CPlayer_pre_check_skill_attack1374_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, struct _skill_fld* pSkillFld, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet, int nEffectGroup, uint16_t* pdwDecPoint, uint16_t wEffBtSerial, struct _STORAGE_LIST::_db_con** ppEffBtProp, struct _BulletItem_fld** ppfldEffBt); bool CPlayer_pre_check_skill_enable1376_wrapper(struct CPlayer* _this, struct _skill_fld* pSkillFld); bool CPlayer_pre_check_skill_gradelimit1378_wrapper(struct CPlayer* _this, struct _skill_fld* pSkillFld); int CPlayer_pre_check_unit_attack1380_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byWeaponPart, struct _UnitPart_fld** ppWeaponFld, struct _UnitBullet_fld** ppBulletFld, struct _unit_bullet_param** ppBulletParam); bool CPlayer_pre_check_wpactive_force_attack1382_wrapper(struct CPlayer* _this); bool CPlayer_pre_check_wpactive_skill_attack1384_wrapper(struct CPlayer* _this, char byEffectCode, struct _skill_fld* pSkillFld, uint16_t wBulletSerial, struct _STORAGE_LIST::_db_con** ppBulletProp, struct _BulletItem_fld** ppfldBullet); void CPlayer_set_db_sf_effect1386_wrapper(struct CPlayer* _this, struct _SFCONT_DB_BASE* pDBBase); void CPlayerapply_case_equip_std_effect1391_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bEquip); void CPlayerapply_case_equip_upgrade_effect1393_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* pItem, bool bEquip); void CPlayerapply_have_item_std_effect1395_wrapper(struct CPlayer* _this, int nEffCode, float fVal, bool bAdd, int nDiffCnt); void CPlayerapply_normal_item_std_effect1397_wrapper(struct CPlayer* _this, int nEffCode, float fVal, bool bEquip); bool CPlayerdev_SetGuildGrade1399_wrapper(struct CPlayer* _this, char byGrade); bool CPlayerdev_SetGuildGradeByGuildSerial1401_wrapper(struct CPlayer* _this, unsigned int dwGuildSerial, char byGrade); bool CPlayerdev_SetGuildGradeByName1403_wrapper(struct CPlayer* _this, char* uszGuildName, char byGrade); bool CPlayerdev_after_effect1405_wrapper(struct CPlayer* _this); bool CPlayerdev_all_kill1407_wrapper(struct CPlayer* _this); bool CPlayerdev_animus_recall_time_free1409_wrapper(struct CPlayer* _this, bool bFree); bool CPlayerdev_avator_copy1411_wrapper(struct CPlayer* _this, char* pwszDstName); bool CPlayerdev_change_class1413_wrapper(struct CPlayer* _this, char* pszClassCode); bool CPlayerdev_cont_effect_del1415_wrapper(struct CPlayer* _this); bool CPlayerdev_cont_effect_time1417_wrapper(struct CPlayer* _this, unsigned int dwSec); bool CPlayerdev_dalant1419_wrapper(struct CPlayer* _this, unsigned int dwDalant); bool CPlayerdev_die1421_wrapper(struct CPlayer* _this); bool CPlayerdev_drop_item1423_wrapper(struct CPlayer* _this, char* pszItemCode, int nNum, char* pszUpTalCode, int nUpNum); bool CPlayerdev_free_sf_by_class1425_wrapper(struct CPlayer* _this); bool CPlayerdev_full_animus_gauge1427_wrapper(struct CPlayer* _this); bool CPlayerdev_full_force1429_wrapper(struct CPlayer* _this); bool CPlayerdev_full_point1431_wrapper(struct CPlayer* _this); bool CPlayerdev_gold1433_wrapper(struct CPlayer* _this, unsigned int dwGold); bool CPlayerdev_goto_monster1435_wrapper(struct CPlayer* _this, struct CMonster* pMon); bool CPlayerdev_goto_npc1437_wrapper(struct CPlayer* _this, struct CMerchant* pNpc); bool CPlayerdev_half_inven_amount1439_wrapper(struct CPlayer* _this, uint64_t dwAmount); bool CPlayerdev_half_point1441_wrapper(struct CPlayer* _this); bool CPlayerdev_init_monster1443_wrapper(struct CPlayer* _this); bool CPlayerdev_inven_empty1445_wrapper(struct CPlayer* _this); bool CPlayerdev_item_make_no_use_matrial1447_wrapper(struct CPlayer* _this, bool noUsingMatrial); bool CPlayerdev_loot_bag1449_wrapper(struct CPlayer* _this); bool CPlayerdev_loot_free1451_wrapper(struct CPlayer* _this, bool bFree); bool CPlayerdev_loot_fullitem1453_wrapper(struct CPlayer* _this, char byLv); bool CPlayerdev_loot_item1455_wrapper(struct CPlayer* _this, char* pszItemCode, int nNum, char* pszUpTalCode, int nUpNum); bool CPlayerdev_loot_material1457_wrapper(struct CPlayer* _this); bool CPlayerdev_loot_mine1459_wrapper(struct CPlayer* _this); bool CPlayerdev_loot_tower1461_wrapper(struct CPlayer* _this); bool CPlayerdev_lv1463_wrapper(struct CPlayer* _this, int nLv); bool CPlayerdev_make_succ1465_wrapper(struct CPlayer* _this, bool bSucc); bool CPlayerdev_max_level_ext1467_wrapper(struct CPlayer* _this, char byMaxLevel); bool CPlayerdev_never_die1469_wrapper(struct CPlayer* _this, bool bSet); bool CPlayerdev_quest_complete1471_wrapper(struct CPlayer* _this); bool CPlayerdev_quest_complete_other1473_wrapper(struct CPlayer* _this, char* pwszCharName); bool CPlayerdev_set_animus_exp1475_wrapper(struct CPlayer* _this, uint64_t dwExpPoint); bool CPlayerdev_set_animus_lv1477_wrapper(struct CPlayer* _this, int nAnimusLv); bool CPlayerdev_set_hp1479_wrapper(struct CPlayer* _this, float prob); bool CPlayerdev_trap_attack_grade1481_wrapper(struct CPlayer* _this, int nPoint); bool CPlayerdev_up_all1483_wrapper(struct CPlayer* _this, int nCum); bool CPlayerdev_up_all_pt1485_wrapper(struct CPlayer* _this, int nLv); bool CPlayerdev_up_cashbag1487_wrapper(struct CPlayer* _this, long double dPoint); bool CPlayerdev_up_forceitem1489_wrapper(struct CPlayer* _this, int nCum); bool CPlayerdev_up_forcemastery1491_wrapper(struct CPlayer* _this, int nCum); bool CPlayerdev_up_mastery1493_wrapper(struct CPlayer* _this, int nMasteryCode, int nMasteryIndex, int nLv); bool CPlayerdev_up_pvp1495_wrapper(struct CPlayer* _this, long double dPoint); bool CPlayerdev_up_skill1497_wrapper(struct CPlayer* _this, char* pszSkillCode, int nCum); bool CPlayerdev_view_boss1499_wrapper(struct CPlayer* _this); bool CPlayerdev_view_method1501_wrapper(struct CPlayer* _this, char* pwszDstName); void CPlayermake_force_attack_param1503_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _force_fld* pForceFld, struct _STORAGE_LIST::_db_con* pForceItem, float* pTar, struct _attack_param* pAP, struct _STORAGE_LIST::_db_con* pEffBulletItem, float fAddEffBtFc); void CPlayermake_gen_attack_param1505_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byPart, struct _BulletItem_fld* pBulletFld, float fAddBulletFc, struct _attack_param* pAP, struct _BulletItem_fld* pEffBtFld, float fAddEffBtFc); void CPlayermake_siege_attack_param1507_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byPart, struct _BulletItem_fld* pBulletFld, float fAddBulletFc, struct _attack_param* pAP, struct _BulletItem_fld* pEffBulletFld, float fAddEffBtFc); void CPlayermake_skill_attack_param1509_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, struct _skill_fld* pSkillFld, int nAttType, struct _STORAGE_LIST::_db_con* pBulletItem, float fAddBulletFc, struct _attack_param* pAP, struct _STORAGE_LIST::_db_con* pEffBulletItem, float fAddEffBulletFc); void CPlayermake_unit_attack_param1511_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _UnitPart_fld* pWeaponFld, float fAddBulletFc, struct _attack_param* pAP); void CPlayermake_wpactive_force_attack_param1513_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _force_fld* pForceFld, float* pfAttackPos, struct _attack_param* pAP); void CPlayermake_wpactive_skill_attack_param1515_wrapper(struct CPlayer* _this, struct CCharacter* pDst, struct _skill_fld* pSkillFld, float* pfAttackPos, char byEffectCode, int nAttType, struct _STORAGE_LIST::_db_con* pBulletItem, float fAddBulletFc, struct _attack_param* pAP, int* nShotNum); bool CPlayermgr_MaxAttackPoint1517_wrapper(struct CPlayer* _this, int nMax); bool CPlayermgr_TrunkInit1519_wrapper(struct CPlayer* _this); bool CPlayermgr_all_item_muzi1521_wrapper(struct CPlayer* _this, int nLv); bool CPlayermgr_change_degree1523_wrapper(struct CPlayer* _this, int nDegree); bool CPlayermgr_defense_item_grace1525_wrapper(struct CPlayer* _this, char byItemCode, int nLv); bool CPlayermgr_destroy_system_tower1527_wrapper(struct CPlayer* _this); bool CPlayermgr_dungeon_pass1529_wrapper(struct CPlayer* _this); bool CPlayermgr_exit_keeper1531_wrapper(struct CPlayer* _this); bool CPlayermgr_exit_stone1533_wrapper(struct CPlayer* _this); bool CPlayermgr_free_ride_ship1535_wrapper(struct CPlayer* _this); bool CPlayermgr_gotoCoordinates1537_wrapper(struct CPlayer* _this, char* pszMapCode, float fX, float fY, float fZ); bool CPlayermgr_gotoDstCoordinates1539_wrapper(struct CPlayer* _this, char* pwszDstName, char* pszMapCode, float fX, float fY, float fZ); bool CPlayermgr_goto_mine1541_wrapper(struct CPlayer* _this); bool CPlayermgr_goto_shipport1543_wrapper(struct CPlayer* _this, int nRaceCode, int nPort); bool CPlayermgr_goto_stone1545_wrapper(struct CPlayer* _this, char byRaceCode); bool CPlayermgr_goto_store1547_wrapper(struct CPlayer* _this, int nRaceCode, char* pszNPCName); bool CPlayermgr_holykeeper_start1549_wrapper(struct CPlayer* _this, int nRace); bool CPlayermgr_holystone_start1551_wrapper(struct CPlayer* _this, int nNumOfTime); bool CPlayermgr_item_telekinesis1553_wrapper(struct CPlayer* _this); bool CPlayermgr_kick1555_wrapper(struct CPlayer* _this, char* pwszCharName); bool CPlayermgr_make_system_tower1557_wrapper(struct CPlayer* _this, char* pszTowerCode); bool CPlayermgr_matchless1559_wrapper(struct CPlayer* _this, bool bMatchless); bool CPlayermgr_pass_sch_one_step1561_wrapper(struct CPlayer* _this); bool CPlayermgr_recall_guild_player1563_wrapper(struct CPlayer* _this, char* wszDestCharName); bool CPlayermgr_recall_mon1565_wrapper(struct CPlayer* _this, char* pszMonCode, int nCreateNum); bool CPlayermgr_recall_party_player1567_wrapper(struct CPlayer* _this, char* wszDestCharName); bool CPlayermgr_recall_player1569_wrapper(struct CPlayer* _this, char* pwszCharName); bool CPlayermgr_resurrect_player1571_wrapper(struct CPlayer* _this, char* pwszCharName); bool CPlayermgr_set_animus_attack_point1573_wrapper(struct CPlayer* _this, int nPoint); bool CPlayermgr_tracing1575_wrapper(struct CPlayer* _this, bool bOn); bool CPlayermgr_user_ban1577_wrapper(struct CPlayer* _this, char* uszCharName, int iPeriod, char* uszReason, char byBlockType); bool CPlayermgr_whisper1579_wrapper(struct CPlayer* _this, char* pwszMsg); void CPlayerpc_AddBag1581_wrapper(struct CPlayer* _this, uint16_t wBagItemSerial); void CPlayerpc_AlterItemSlotRequest1583_wrapper(struct CPlayer* _this, char byNum, struct _alter_item_slot_request_clzo::__list* pList); void CPlayerpc_AlterLinkBoardSlotRequest1585_wrapper(struct CPlayer* _this, char byNum, struct _alter_link_slot_request_clzo::__list* pList, char byLBLock); void CPlayerpc_AlterWindowInfoRequest1587_wrapper(struct CPlayer* _this, unsigned int* pdwSkill, unsigned int* pdwForce, unsigned int* pdwChar, unsigned int* pdwAnimus, unsigned int dwInven, unsigned int* pdwInvenBag); void CPlayerpc_AnimusCommandRequest1589_wrapper(struct CPlayer* _this, char byCommandCode); void CPlayerpc_AnimusInvenChange1591_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wReplaceSerial); void CPlayerpc_AnimusRecallRequest1593_wrapper(struct CPlayer* _this, uint16_t wAnimusItemSerial, uint16_t wAnimusClientHP, uint16_t wAnimusClientFP); void CPlayerpc_AnimusReturnRequest1595_wrapper(struct CPlayer* _this); void CPlayerpc_AnimusTargetRequest1597_wrapper(struct CPlayer* _this, char byObjectID, uint16_t wObjectIndex, unsigned int dwObjectSerial); void CPlayerpc_AwayPartyJoinInvitationAnswer1599_wrapper(struct CPlayer* _this, struct _CLID* pidBoss, char byRetCode); void CPlayerpc_AwaypartyInvitationRequest1601_wrapper(struct CPlayer* _this, char* pwszCharName); void CPlayerpc_BackTowerRequest1603_wrapper(struct CPlayer* _this, unsigned int dwTowerObjSerial); void CPlayerpc_BackTrapRequest1605_wrapper(struct CPlayer* _this, unsigned int dwTrapObjSerial, uint16_t wAddSerial); void CPlayerpc_BillingInfoRequest1607_wrapper(struct CPlayer* _this); void CPlayerpc_BriefPass1609_wrapper(struct CPlayer* _this, char byQuestSlotIndex); void CPlayerpc_BuddyAddAnswer1611_wrapper(struct CPlayer* _this, bool bAccept, uint16_t wAskerIndex, unsigned int dwAskerSerial); void CPlayerpc_BuddyAddRequest1613_wrapper(struct CPlayer* _this, uint16_t wDstIndex, unsigned int dwDstSerial, char* pwszDstName); void CPlayerpc_BuddyDelRequest1615_wrapper(struct CPlayer* _this, unsigned int dwSerial); void CPlayerpc_BuddyDownloadRequest1617_wrapper(struct CPlayer* _this); void CPlayerpc_BuyItemStore1619_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byOfferNum, struct _buy_store_request_clzo::_list* pList, int bUseNPCLinkIntem); char CPlayerpc_CanSelectClassRequest1621_wrapper(struct CPlayer* _this, char* pIsRealClassUp); void CPlayerpc_CastVoteRequest1623_wrapper(struct CPlayer* _this, int nVoteSerial, char byCode); void CPlayerpc_ChangeModeType1625_wrapper(struct CPlayer* _this, int nModeType, int nStandType); bool CPlayerpc_CharacterRenameCash1627_wrapper(struct CPlayer* _this, bool bChange, struct _STORAGE_POS_INDIV* pItem, char* strCharacterName); char CPlayerpc_CharacterRenameCheck1629_wrapper(struct CPlayer* _this, char* strCharacterName); void CPlayerpc_ChatAllRequest1631_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatCircleRequest1633_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatFarRequest1635_wrapper(struct CPlayer* _this, char* pwszName, char* pwszChatData); void CPlayerpc_ChatGmNoticeRequest1637_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatGuildEstSenRequest1639_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatGuildRequest1641_wrapper(struct CPlayer* _this, unsigned int dwDstSerial, char* pwszChatData); void CPlayerpc_ChatMapRequest1643_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatMgrWhisperRequest1645_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatMultiFarRequest1647_wrapper(struct CPlayer* _this, char byDstNum, struct _w_name* pDstName, char* pwszMsg); void CPlayerpc_ChatOperatorRequest1649_wrapper(struct CPlayer* _this, char byRaceCode, char* pwszChatData); void CPlayerpc_ChatPartyRequest1651_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatRaceBossCryRequest1653_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatRaceBossRequest1655_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatRaceRequest1657_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatRePresentationRequest1659_wrapper(struct CPlayer* _this, char* pwszChatData); void CPlayerpc_ChatTradeRequestMsg1661_wrapper(struct CPlayer* _this, char bySubType, char* pwszTradeMsg); void CPlayerpc_ClassSkillRequest1663_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial); void CPlayerpc_CombineItem1665_wrapper(struct CPlayer* _this, uint16_t wManualIndex, char byMaterialNum, struct _STORAGE_POS_INDIV* pipMaterials, uint16_t wOverlapSerial); void CPlayerpc_CombineItemEx1667_wrapper(struct CPlayer* _this, struct _combine_ex_item_request_clzo* pRecv); void CPlayerpc_CombineItemExAccept1669_wrapper(struct CPlayer* _this, struct _combine_ex_item_accept_request_clzo* pRecv); void CPlayerpc_CuttingComplete1671_wrapper(struct CPlayer* _this, char byNpcRace); void CPlayerpc_DTradeAddRequest1673_wrapper(struct CPlayer* _this, char bySlotIndex, char byStorageCode, unsigned int dwSerial, char byAmount); void CPlayerpc_DTradeAnswerRequest1675_wrapper(struct CPlayer* _this, struct _CLID* pidAsker); void CPlayerpc_DTradeAskRequest1677_wrapper(struct CPlayer* _this, uint16_t wDstIndex); void CPlayerpc_DTradeBetRequest1679_wrapper(struct CPlayer* _this, char byMoneyUnit, unsigned int dwBetAmount); void CPlayerpc_DTradeCancleRequest1681_wrapper(struct CPlayer* _this); void CPlayerpc_DTradeDelRequest1683_wrapper(struct CPlayer* _this, char bySlotIndex); void CPlayerpc_DTradeLockRequest1685_wrapper(struct CPlayer* _this); void CPlayerpc_DTradeOKRequest1687_wrapper(struct CPlayer* _this, unsigned int* pdwKey); void CPlayerpc_DarkHoleAnswerReenterRequest1689_wrapper(struct CPlayer* _this, bool bEnter, uint16_t wChannelIndex, unsigned int dwChannelSerial); void CPlayerpc_DarkHoleClearOutRequest1691_wrapper(struct CPlayer* _this); void CPlayerpc_DarkHoleEnterRequest1693_wrapper(struct CPlayer* _this, uint16_t wHoleIndex, unsigned int dwHoleSerial); void CPlayerpc_DarkHoleGiveupOutRequest1695_wrapper(struct CPlayer* _this); void CPlayerpc_DarkHoleOpenRequest1697_wrapper(struct CPlayer* _this, unsigned int dwItemSerial); void CPlayerpc_DowngradeItem1699_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pposTalik, struct _STORAGE_POS_INDIV* pposToolItem, struct _STORAGE_POS_INDIV* pposUpgItem); void CPlayerpc_EmbellishPart1701_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wChangeSerial); void CPlayerpc_EquipPart1703_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem); void CPlayerpc_ExchangeDalantForGold1705_wrapper(struct CPlayer* _this, unsigned int dwDalant); void CPlayerpc_ExchangeGoldForDalant1707_wrapper(struct CPlayer* _this, unsigned int dwGold); void CPlayerpc_ExchangeGoldForPvP1709_wrapper(struct CPlayer* _this, unsigned int dwGold); void CPlayerpc_ExchangeItem1711_wrapper(struct CPlayer* _this, uint16_t wManualIndex, uint16_t wItemSerial); void CPlayerpc_ExitWorldRequest1713_wrapper(struct CPlayer* _this); void CPlayerpc_ForceInvenChange1715_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t wReplaceSerial); void CPlayerpc_ForceRequest1717_wrapper(struct CPlayer* _this, uint16_t wForceSerial, struct _CHRID* pidDst, uint16_t* pConsumeSerial); void CPlayerpc_GestureRequest1719_wrapper(struct CPlayer* _this, char byGestureType); bool CPlayerpc_GiveItem1721_wrapper(struct CPlayer* _this, struct _STORAGE_LIST::_db_con* kItem, char* szReason, bool bDrop); void CPlayerpc_GotoAvatorRequest1723_wrapper(struct CPlayer* _this, char* pwszAvatorName); void CPlayerpc_GotoBasePortalRequest1725_wrapper(struct CPlayer* _this, uint16_t wItemSerial); void CPlayerpc_GuildBattleBlock1727_wrapper(struct CPlayer* _this, bool bBlock); void CPlayerpc_GuildCancelSuggestRequest1729_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey); void CPlayerpc_GuildDownLoadRequest1731_wrapper(struct CPlayer* _this); void CPlayerpc_GuildEstablishRequest1733_wrapper(struct CPlayer* _this, char* pwszGuildName); void CPlayerpc_GuildHonorListRequest1735_wrapper(struct CPlayer* _this, char byUI); void CPlayerpc_GuildJoinAcceptRequest1737_wrapper(struct CPlayer* _this, unsigned int dwApplierSerial, bool bAccept); void CPlayerpc_GuildJoinApplyCancelRequest1739_wrapper(struct CPlayer* _this); void CPlayerpc_GuildJoinApplyRequest1741_wrapper(struct CPlayer* _this, char* pwszGuildName); void CPlayerpc_GuildListRequest1743_wrapper(struct CPlayer* _this, char byPage); void CPlayerpc_GuildManageRequest1745_wrapper(struct CPlayer* _this, char byType, unsigned int dwDst, unsigned int dwObj1, unsigned int dwObj2, unsigned int dwObj3); void CPlayerpc_GuildNextHonorListRequest1747_wrapper(struct CPlayer* _this); void CPlayerpc_GuildOfferSuggestRequest1749_wrapper(struct CPlayer* _this, char byMatterType, unsigned int dwMatterDst, char* pwszComment, unsigned int dwMatterObj1, unsigned int dwMatterObj2, unsigned int dwMatterObj3); void CPlayerpc_GuildPushMoneyRequest1751_wrapper(struct CPlayer* _this, unsigned int dwPushDalant, unsigned int dwPushGold); void CPlayerpc_GuildQueryInfoRequest1753_wrapper(struct CPlayer* _this, unsigned int dwGuildSerial); void CPlayerpc_GuildRoomEnterRequest1755_wrapper(struct CPlayer* _this, struct _guildroom_enter_request_clzo* pProtocol); void CPlayerpc_GuildRoomOutRequest1757_wrapper(struct CPlayer* _this, struct _guildroom_out_request_clzo* pProtocol); void CPlayerpc_GuildRoomRentRequest1759_wrapper(struct CPlayer* _this, struct _guildroom_rent_request_clzo* pProtocol); void CPlayerpc_GuildRoomRestTimeRequest1761_wrapper(struct CPlayer* _this, struct _guildroom_resttime_request_clzo* pProtocol); void CPlayerpc_GuildSelfLeaveRequest1763_wrapper(struct CPlayer* _this); void CPlayerpc_GuildSetHonorRequest1765_wrapper(struct CPlayer* _this, struct _guild_honor_set_request_clzo* pData); void CPlayerpc_GuildVoteRequest1767_wrapper(struct CPlayer* _this, unsigned int dwMatterVoteSynKey, char byVoteCode); char CPlayerpc_InitClass1769_wrapper(struct CPlayer* _this); char CPlayerpc_InitClassRequest1771_wrapper(struct CPlayer* _this); void CPlayerpc_LimitItemNumRequest1773_wrapper(struct CPlayer* _this, unsigned int dwStoreIndex); void CPlayerpc_LinkBoardRequest1775_wrapper(struct CPlayer* _this); void CPlayerpc_MacroUpdate1777_wrapper(struct CPlayer* _this, char* pBuf); void CPlayerpc_MakeItem1779_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pipMakeTool, uint16_t wManualIndex, char byMaterialNum, struct _STORAGE_POS_INDIV* pipMaterials); void CPlayerpc_MakeTowerRequest1781_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, uint16_t wTowerItemSerial, char byMaterialNum, struct _make_tower_request_clzo::__material* pMaterial, float* pfPos, uint16_t* pConsumeSerial); void CPlayerpc_MakeTrapRequest1783_wrapper(struct CPlayer* _this, uint16_t wSkillIndex, uint16_t wTrapItemSerial, float* pfPos, uint16_t* pConsumeSerial); void CPlayerpc_MineCancle1785_wrapper(struct CPlayer* _this); void CPlayerpc_MineComplete1787_wrapper(struct CPlayer* _this); void CPlayerpc_MineStart1789_wrapper(struct CPlayer* _this, char byMineIndex, char byOreIndex, uint16_t wBatterySerial); void CPlayerpc_MoveModeChangeRequest1791_wrapper(struct CPlayer* _this, char byMoveType); void CPlayerpc_MoveNext1793_wrapper(struct CPlayer* _this, char byMoveType, float* pfCur, float* pfTar, char byDirect); void CPlayerpc_MovePortal1795_wrapper(struct CPlayer* _this, int nPortalIndex, uint16_t* pConsumeSerial); void CPlayerpc_MoveStop1797_wrapper(struct CPlayer* _this, float* pfCur); void CPlayerpc_MoveToOwnStoneMapRequest1799_wrapper(struct CPlayer* _this); bool CPlayerpc_NPCLinkCheckItemRequest1801_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage); char CPlayerpc_NPCLinkCheckItemRequest_Check1803_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage); char CPlayerpc_NPCLinkCheckItemRequest_Use1805_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pStorage); void CPlayerpc_NewPosStart1807_wrapper(struct CPlayer* _this); void CPlayerpc_NotifyRaceBossCryMsg1809_wrapper(struct CPlayer* _this); void CPlayerpc_NuclearAfterEffect1811_wrapper(struct CPlayer* _this); void CPlayerpc_OffPart1813_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem); void CPlayerpc_OreCutting1815_wrapper(struct CPlayer* _this, uint16_t wOreSerial, char byProcessNum); void CPlayerpc_OreIntoBag1817_wrapper(struct CPlayer* _this, uint16_t wResIndex, uint16_t wSerial, char byAddAmount); void CPlayerpc_PartyAlterLootShareReqeuest1819_wrapper(struct CPlayer* _this, char byLootShareMode); void CPlayerpc_PartyDisJointReqeuest1821_wrapper(struct CPlayer* _this); void CPlayerpc_PartyJoinApplication1823_wrapper(struct CPlayer* _this, uint16_t wBossIndex); void CPlayerpc_PartyJoinApplicationAnswer1825_wrapper(struct CPlayer* _this, struct _CLID* pidApplicant); void CPlayerpc_PartyJoinInvitation1827_wrapper(struct CPlayer* _this, uint16_t wDstIndex); void CPlayerpc_PartyJoinInvitationAnswer1829_wrapper(struct CPlayer* _this, struct _CLID* pidBoss); void CPlayerpc_PartyLeaveCompulsionReqeuest1831_wrapper(struct CPlayer* _this, unsigned int dwExiterSerial); void CPlayerpc_PartyLeaveSelfReqeuest1833_wrapper(struct CPlayer* _this); void CPlayerpc_PartyLockReqeuest1835_wrapper(struct CPlayer* _this, bool bLock); void CPlayerpc_PartyReqBlock1837_wrapper(struct CPlayer* _this, bool bBlock); void CPlayerpc_PartySuccessionReqeuest1839_wrapper(struct CPlayer* _this, unsigned int dwSuccessorSerial); void CPlayerpc_PlayAttack_Force1841_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAreaPos, uint16_t wForceSerial, uint16_t* pConsumeSerial, uint16_t wEffBtSerial); void CPlayerpc_PlayAttack_Gen1843_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byAttPart, uint16_t wBulletSerial, uint16_t wEffBtSerial, bool bCount); void CPlayerpc_PlayAttack_SelfDestruction1845_wrapper(struct CPlayer* _this); void CPlayerpc_PlayAttack_Siege1847_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byAttPart, uint16_t wBulletSerial, uint16_t wEffBtSerial); void CPlayerpc_PlayAttack_Skill1849_wrapper(struct CPlayer* _this, struct CCharacter* pDst, float* pfAttackPos, char byEffectCode, uint16_t wSkillIndex, uint16_t wBulletSerial, uint16_t* pConsumeSerial, uint16_t wEffBtSerial); void CPlayerpc_PlayAttack_Test1851_wrapper(struct CPlayer* _this, char byEffectCode, char byEffectIndex, uint16_t wBulletItemSerial, char byWeaponPart, int16_t* pzTar); void CPlayerpc_PlayAttack_Unit1853_wrapper(struct CPlayer* _this, struct CCharacter* pDst, char byWeaponPart); void CPlayerpc_PostContentRequest1855_wrapper(struct CPlayer* _this, unsigned int dwIndex); void CPlayerpc_PostDeleteRequest1857_wrapper(struct CPlayer* _this, unsigned int dwIndex); void CPlayerpc_PostItemGoldRequest1859_wrapper(struct CPlayer* _this, unsigned int dwIndex); void CPlayerpc_PostListRequest1861_wrapper(struct CPlayer* _this); void CPlayerpc_PostReturnConfirmRequest1863_wrapper(struct CPlayer* _this, unsigned int dwPostSerial); void CPlayerpc_PotionDivision1865_wrapper(struct CPlayer* _this, uint16_t wSerial, uint16_t wTarSerial, char byAmount); void CPlayerpc_PotionSeparation1867_wrapper(struct CPlayer* _this, uint16_t wSerial, char byAmount); void CPlayerpc_PotionUseTrunkExtend1869_wrapper(struct CPlayer* _this); void CPlayerpc_ProposeVoteRequest1871_wrapper(struct CPlayer* _this, char byLimGrade, char* pwszCont); void CPlayerpc_PvpCashRecorver1873_wrapper(struct CPlayer* _this, unsigned int dwItemSerial, char byItemCnt); void CPlayerpc_QuestGiveupRequest1875_wrapper(struct CPlayer* _this, char byQuestDBSlot); bool CPlayerpc_RadarCharInfo1877_wrapper(struct CPlayer* _this); void CPlayerpc_RealMovPos1879_wrapper(struct CPlayer* _this, float* pfCur); void CPlayerpc_RefreshGroupTargetPosition1881_wrapper(struct CPlayer* _this, char byGroupType, struct CGameObject* pObject); void CPlayerpc_RegistBind1883_wrapper(struct CPlayer* _this, struct CItemStore* pStore); void CPlayerpc_ReleaseGroupTargetObjectRequest1885_wrapper(struct CPlayer* _this, char byGroupType); void CPlayerpc_ReleaseSiegeModeRequest1887_wrapper(struct CPlayer* _this); void CPlayerpc_ReleaseTargetObjectRequest1889_wrapper(struct CPlayer* _this); char CPlayerpc_RenameItemNConditionCheck1891_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItemInfo, struct _STORAGE_LIST::_db_con** ppItem); void CPlayerpc_RequestChangeTaxRate1893_wrapper(struct CPlayer* _this, char byTaxRate); void CPlayerpc_RequestDialogWithNPC1895_wrapper(struct CPlayer* _this, struct CItemStore* pStore); void CPlayerpc_RequestPatriarchPunishment1897_wrapper(struct CPlayer* _this, char byType, char* pwszName, char* pwszCont); void CPlayerpc_RequestQuestFromNPC1899_wrapper(struct CPlayer* _this, struct CItemStore* pStore, unsigned int dwNPCQuestIndex); void CPlayerpc_RequestQuestListFromNPC1901_wrapper(struct CPlayer* _this, struct CItemStore* pStore); void CPlayerpc_RequestTaxRate1903_wrapper(struct CPlayer* _this); void CPlayerpc_RequestUILockCertify1905_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* uszUILockPW); void CPlayerpc_RequestUILockFindPW1907_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* uszHintAnswer); void CPlayerpc_RequestUILockInit1909_wrapper(struct CPlayer* _this, struct CUserDB* pUserDB, char* szUILockPW, char* szUILockPW_Confirm, char byUILock_HintIndex, char* uszUILock_HintAnswer); void CPlayerpc_RequestUILockUpdate1911_wrapper(struct CPlayer* _this, char* uszUILockPWOld, char* uszUILockPW, char* uszUILockPW_Confirm, char byUILock_HintIndex, char* uszUILock_HintAnswer); void CPlayerpc_RequestWatchingWithNPC1913_wrapper(struct CPlayer* _this, struct CItemStore* pStore); void CPlayerpc_ResDivision1915_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, char byMoveAmount); void CPlayerpc_ResSeparation1917_wrapper(struct CPlayer* _this, uint16_t wStartSerial, char byMoveAmount); bool CPlayerpc_Resurrect1919_wrapper(struct CPlayer* _this, bool bQuickPotion); void CPlayerpc_Revival1921_wrapper(struct CPlayer* _this, bool bUseableJade); void CPlayerpc_SelectClassRequest1923_wrapper(struct CPlayer* _this, uint16_t wSelClassIndex, char bySelectRewardItem); void CPlayerpc_SelectQuestAfterHappenEvent1925_wrapper(struct CPlayer* _this, char bySelectIndex); void CPlayerpc_SelectQuestReward1927_wrapper(struct CPlayer* _this, char byQuestDBSlot, char bySelectItemSlotIndex, char bySelectLinkQuestIndex); void CPlayerpc_SellItemStore1929_wrapper(struct CPlayer* _this, struct CItemStore* pStore, char byOfferNum, struct _sell_store_request_clzo::_list* pList, int bUseNPCLinkIntem); void CPlayerpc_SetGroupMapPointRequest1931_wrapper(struct CPlayer* _this, char byGroupType, float* pzTar); void CPlayerpc_SetGroupTargetObjectRequest1933_wrapper(struct CPlayer* _this, struct CGameObject* pTar, unsigned int dwSerial, char byGroupType); void CPlayerpc_SetInGuildBattle1935_wrapper(struct CPlayer* _this, bool bInGuildBattle, char byColorInx); bool CPlayerpc_SetItemCheckRequest1937_wrapper(struct CPlayer* _this, unsigned int dwSetItem, char bySetItemNum, char bySetEffectNum, bool bSet); void CPlayerpc_SetRaceBossCryMsg1939_wrapper(struct CPlayer* _this, char bySlot, char* pwszCryMsg); void CPlayerpc_SetTargetObjectRequest1941_wrapper(struct CPlayer* _this, struct CGameObject* pTar, unsigned int dwSerial, bool bForce); void CPlayerpc_SkillRequest1943_wrapper(struct CPlayer* _this, char bySkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial); void CPlayerpc_Stop1945_wrapper(struct CPlayer* _this); void CPlayerpc_TakeGroundingItem1947_wrapper(struct CPlayer* _this, struct CItemBox* pBox, uint16_t wAddSerial); void CPlayerpc_TalikCrystalExchange1949_wrapper(struct CPlayer* _this, char byExchangeNum, struct _talik_crystal_exchange_clzo::_list* pList); void CPlayerpc_ThrowSkillRequest1951_wrapper(struct CPlayer* _this, uint16_t wBulletSerial, struct _CHRID* pidDst, uint16_t* pConsumeSerial); void CPlayerpc_ThrowStorageItem1953_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem); void CPlayerpc_ThrowUnitRequest1955_wrapper(struct CPlayer* _this, struct _CHRID* pidDst, uint16_t* pConsumeSerial); void CPlayerpc_TradeBlock1957_wrapper(struct CPlayer* _this, bool bBlock); void CPlayerpc_TransShipRenewTicketRequest1959_wrapper(struct CPlayer* _this, uint16_t wTicketItemSerial); void CPlayerpc_TransformSiegeModeRequest1961_wrapper(struct CPlayer* _this, uint16_t wItemSerial); void CPlayerpc_TrunkAlterItemSlotRequest1963_wrapper(struct CPlayer* _this, unsigned int dwItemSerial, char byClientSlotIndex, char byStorageIndex); void CPlayerpc_TrunkChangePasswdRequest1965_wrapper(struct CPlayer* _this, char* pwszPrevPassword, char* pwszChngPassword, char byHintIndex, char* pwszHintAnswer); char CPlayerpc_TrunkCreateCostIsFreeRequest1967_wrapper(struct CPlayer* _this); void CPlayerpc_TrunkDownloadRequest1969_wrapper(struct CPlayer* _this, char* pwszPassword); void CPlayerpc_TrunkEstRequest1971_wrapper(struct CPlayer* _this, char* pwszPassword, char byHintIndex, char* pwszHintAnswer); void CPlayerpc_TrunkExtendRequest1973_wrapper(struct CPlayer* _this); void CPlayerpc_TrunkHintAnswerRequest1975_wrapper(struct CPlayer* _this, char* pwszAnswer); void CPlayerpc_TrunkIoMergeRequest1977_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wStartItemSerial, uint16_t wTarItemSerial, uint16_t wMoveAmount); void CPlayerpc_TrunkIoMoneyRequest1979_wrapper(struct CPlayer* _this, char byCase, unsigned int dwDalant, unsigned int dwGold); void CPlayerpc_TrunkIoMoveRequest1981_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wItemSerial, char byClientSlotIndex); void CPlayerpc_TrunkIoSwapRequest1983_wrapper(struct CPlayer* _this, char byStartStorageIndex, char byTarStorageIndex, uint16_t wStartItemSerial, uint16_t wTarItemSerial); void CPlayerpc_TrunkPotionDivision1985_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, uint16_t wMoveAmount, char byStorageIndex); void CPlayerpc_TrunkPwHintIndexRequest1987_wrapper(struct CPlayer* _this); void CPlayerpc_TrunkResDivision1989_wrapper(struct CPlayer* _this, uint16_t wStartSerial, uint16_t wTarSerial, uint16_t wMoveAmount, char byStorageIndex); void CPlayerpc_UnitBulletFillRequest1991_wrapper(struct CPlayer* _this, char bySlotIndex, uint16_t* pwBulletIndex, int bUseNPCLinkIntem); void CPlayerpc_UnitBulletReplaceRequest1993_wrapper(struct CPlayer* _this, char bySlotIndex, char byPackIndex, char byBulletPart); void CPlayerpc_UnitDeliveryRequest1995_wrapper(struct CPlayer* _this, char bySlotIndex, struct CItemStore* pStore, bool bPayFee, float* pfNewPos, int bUseNPCLinkIntem); void CPlayerpc_UnitFrameBuyRequest1997_wrapper(struct CPlayer* _this, char byFrameCode, int bUseNPCLinkIntem); void CPlayerpc_UnitFrameRepairRequest1999_wrapper(struct CPlayer* _this, char bySlotIndex, int bUseNPCLinkIntem); void CPlayerpc_UnitLeaveRequest2001_wrapper(struct CPlayer* _this, float* pfNewPos); void CPlayerpc_UnitPackFillRequest2003_wrapper(struct CPlayer* _this, char bySlotIndex, char byFillNum, struct _unit_pack_fill_request_clzo::__list* pList, int bUseNPCLinkIntem); void CPlayerpc_UnitPartTuningRequest2005_wrapper(struct CPlayer* _this, char bySlotIndex, char byTuningNum, struct _tuning_data* pTuningData, int bUseNPCLinkIntem); void CPlayerpc_UnitReturnRequest2007_wrapper(struct CPlayer* _this); void CPlayerpc_UnitSellRequest2009_wrapper(struct CPlayer* _this, char bySlotIndex, int bUseNPCLinkIntem); void CPlayerpc_UnitTakeRequest2011_wrapper(struct CPlayer* _this); void CPlayerpc_UpdateDataForPostSend2013_wrapper(struct CPlayer* _this); void CPlayerpc_UpdateDataForTrade2015_wrapper(struct CPlayer* _this, struct CPlayer* pTrader); void CPlayerpc_UpgradeItem2017_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pposTalik, struct _STORAGE_POS_INDIV* pposToolItem, struct _STORAGE_POS_INDIV* pposUpgItem, char byJewelNum, struct _STORAGE_POS_INDIV* pposUpgJewel); int CPlayerpc_UseFireCracker2019_wrapper(struct CPlayer* _this, uint16_t wItemSerial); void CPlayerpc_UsePotionItem2021_wrapper(struct CPlayer* _this, struct CPlayer* pTargetPlayer, struct _STORAGE_POS_INDIV* pItem); bool CPlayerpc_UseRadarItem2023_wrapper(struct CPlayer* _this, struct _STORAGE_POS_INDIV* pItem, uint16_t* pConsumeSerial); char CPlayerpc_UseRecoverLossExpItem2025_wrapper(struct CPlayer* _this, uint16_t wItemSerial); char CPlayerpc_UserSoccerBall2027_wrapper(struct CPlayer* _this, uint16_t wItemSerial, uint16_t* wItemIndex); bool CPlayerpc_WPActiveAttack_Force2029_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, struct _force_fld* pForceFld); bool CPlayerpc_WPActiveAttack_Skill2031_wrapper(struct CPlayer* _this, struct _be_damaged_char* pDamList, int* nDamagedObjNum, int* nShotNum, struct _skill_fld* pSkillFld, char byEffectCode, uint16_t wBulletSerial); void CPlayerpc_WhisperBlock2033_wrapper(struct CPlayer* _this, bool bBlock); char CPlayerskill_process2035_wrapper(struct CPlayer* _this, int nEffectCode, int nSkillIndex, struct _CHRID* pidDst, uint16_t* pConsumeSerial, int* pnLv); void CPlayerskill_process_for_aura2037_wrapper(struct CPlayer* _this, int nSkillIndex); char CPlayerskill_process_for_item2039_wrapper(struct CPlayer* _this, int nSkillIndex, struct _CHRID* pidDst, int* pnLv); void CPlayerdtor_CPlayer2041_wrapper(struct CPlayer* _this);

b4fda61d3957f43b7864605f36f3154bc66c188b05b0350456e1bc0fcf082cc0

ex

godot

Deps/bullet/src/BulletCollision/CollisionShapes/btBox2dShape.cpp

btBox2dShape::calculateLocalInertia

void btBox2dShape::calculateLocalInertia(btScalar mass, btVector3& inertia) const { btVector3 halfExtents = getHalfExtentsWithMargin(); btScalar lx = btScalar(2.) * (halfExtents.x()); btScalar ly = btScalar(2.) * (halfExtents.y()); btScalar lz = btScalar(2.) * (halfExtents.z()); inertia.setValue(mass / (btScalar(12.0)) * (ly * ly + lz * lz), mass / (btScalar(12.0)) * (lx * lx + lz * lz), mass / (btScalar(12.0)) * (lx * lx + ly * ly)); }

void btBox2dShape::getAabb(const btTransform& t, btVector3& aabbMin, btVector3& aabbMax);

ee07e5e02d42616414fbe7aa7b5fa2c499bd3d3ce803a95bec45a16e2cb2693b

kcotugno

Natron

Engine/OfxParamInstance.cpp

OfxStatus OfxInteger3DInstance::copyFrom

OfxStatus OfxInteger3DInstance::copyFrom(const OFX::Host::Param::Instance &instance, OfxTime offset, const OfxRangeD* range) { const OfxParamToKnob & other = dynamic_cast<const OfxParamToKnob &>(instance); return OfxKeyFrame::copyFrom(other.getKnob(), getKnob(), offset, range); }

bool operator(); PropertyModified_RAII::PropertyModified_RAII(OfxParamToKnob* h); PropertyModified_RAII::~PropertyModified_RAII(); static boost::shared_ptr<K> resolveRenderKnob(const KnobIPtr& originalKnob); OfxStringInstancePrivate(); OfxStringInstance::~OfxStringInstance(); OfxCustomInstancePrivate(); OfxCustomInstance::~OfxCustomInstance(); OfxParametricInstance::~OfxParametricInstance();

d782cbc4c22a931e62a62c87db3397018929fe67076c0cabc38b3aca6ea84084

DigitalPulseSoftware

NazaraEngine

src/Nazara/Physics2D/Constraint2D.cpp

RotaryLimitConstraint2D::GetMinAngle

adianAnglef RotaryLimitConstraint2D::GetMinAngle() const { return float(cpRotaryLimitJointGetMax(m_constraint)); }

onstraint2D::Constraint2D(Nz::PhysWorld2D* world, cpConstraint* constraint); onstraint2D::Constraint2D(Constraint2D&& rhs); onstraint2D::~Constraint2D(); oid Constraint2D::EnableBodyCollision(bool enable); igidBody2D& Constraint2D::GetBodyA(); onst RigidBody2D& Constraint2D::GetBodyA(); igidBody2D& Constraint2D::GetBodyB(); onst RigidBody2D& Constraint2D::GetBodyB(); loat Constraint2D::GetErrorBias(); loat Constraint2D::GetLastImpulse(); loat Constraint2D::GetMaxBias(); loat Constraint2D::GetMaxForce(); hysWorld2D& Constraint2D::GetWorld(); onst PhysWorld2D& Constraint2D::GetWorld(); ool Constraint2D::IsBodyCollisionEnabled(); oid Constraint2D::SetErrorBias(float bias); oid Constraint2D::SetMaxBias(float bias); oid Constraint2D::SetMaxForce(float force); onstraint2D& Constraint2D::operator=(Constraint2D && rhs); ampedSpringConstraint2D::DampedSpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float restLength, float stiffness, float damping); loat DampedSpringConstraint2D::GetDamping(); ector2f DampedSpringConstraint2D::GetFirstAnchor(); loat DampedSpringConstraint2D::GetRestLength(); ector2f DampedSpringConstraint2D::GetSecondAnchor(); loat DampedSpringConstraint2D::GetStiffness(); oid DampedSpringConstraint2D::SetDamping(float newDamping); oid DampedSpringConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor); oid DampedSpringConstraint2D::SetRestLength(float newLength); oid DampedSpringConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor); oid DampedSpringConstraint2D::SetStiffness(float newStiffness); ampedRotarySpringConstraint2D::DampedRotarySpringConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& restAngle, float stiffness, float damping); loat DampedRotarySpringConstraint2D::GetDamping(); adianAnglef DampedRotarySpringConstraint2D::GetRestAngle(); loat DampedRotarySpringConstraint2D::GetStiffness(); oid DampedRotarySpringConstraint2D::SetDamping(float newDamping); oid DampedRotarySpringConstraint2D::SetRestAngle(const RadianAnglef& newAngle); oid DampedRotarySpringConstraint2D::SetStiffness(float newStiffness); earConstraint2D::GearConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratio); loat GearConstraint2D::GetPhase(); loat GearConstraint2D::GetRatio(); oid GearConstraint2D::SetPhase(float phase); oid GearConstraint2D::SetRatio(float ratio); otorConstraint2D::MotorConstraint2D(RigidBody2D& first, RigidBody2D& second, float rate); loat MotorConstraint2D::GetRate(); oid MotorConstraint2D::SetRate(float rate); inConstraint2D::PinConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); loat PinConstraint2D::GetDistance(); ector2f PinConstraint2D::GetFirstAnchor(); ector2f PinConstraint2D::GetSecondAnchor(); oid PinConstraint2D::SetDistance(float newDistance); oid PinConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor); oid PinConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor); ivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& anchor); ivotConstraint2D::PivotConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor); ector2f PivotConstraint2D::GetFirstAnchor(); ector2f PivotConstraint2D::GetSecondAnchor(); oid PivotConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor); oid PivotConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor); atchetConstraint2D::RatchetConstraint2D(RigidBody2D& first, RigidBody2D& second, float phase, float ratchet); adianAnglef RatchetConstraint2D::GetAngle(); loat RatchetConstraint2D::GetPhase(); loat RatchetConstraint2D::GetRatchet(); oid RatchetConstraint2D::SetAngle(const RadianAnglef& angle); oid RatchetConstraint2D::SetPhase(float phase); oid RatchetConstraint2D::SetRatchet(float ratchet); otaryLimitConstraint2D::RotaryLimitConstraint2D(RigidBody2D& first, RigidBody2D& second, const RadianAnglef& minAngle, const RadianAnglef& maxAngle); adianAnglef RotaryLimitConstraint2D::GetMaxAngle(); oid RotaryLimitConstraint2D::SetMaxAngle(const RadianAnglef& maxAngle); oid RotaryLimitConstraint2D::SetMinAngle(const RadianAnglef& minAngle); lideConstraint2D::SlideConstraint2D(RigidBody2D& first, RigidBody2D& second, const Vector2f& firstAnchor, const Vector2f& secondAnchor, float min, float max); ector2f SlideConstraint2D::GetFirstAnchor(); loat SlideConstraint2D::GetMaxDistance(); loat SlideConstraint2D::GetMinDistance(); ector2f SlideConstraint2D::GetSecondAnchor(); oid SlideConstraint2D::SetFirstAnchor(const Vector2f& firstAnchor); oid SlideConstraint2D::SetMaxDistance(float newMaxDistance); oid SlideConstraint2D::SetMinDistance(float newMinDistance); oid SlideConstraint2D::SetSecondAnchor(const Vector2f& firstAnchor);

dbf3746e177526b69724fe9fd4948314c558e40914db0bfae0a8a9b032a98f1c

millerp

IGC.GameServer

GameServer/Bag.cpp

CBag::CBag

CBag::CBag() { this->InitBag(); }

CBag::~CBag(); bool CBag::LoadBag(const char *lpFileName); void CBag::InitBag(); int CBag::GetDropSection(int aIndex, BAG_SECTION_DROP &pRetDrop); int CBag::GetItemsSection(BAG_SECTION_DROP &pDropSec, BAG_SECTION_ITEMS &pRetItems); int CBag::GetItem(BAG_SECTION_ITEMS &pItemsSec, BAG_ITEM &pRetItem); int CBag::GetReadyItemToUse(int aIndex, CItem &pItem, time_t &DurationItem); int CBag::GetItemLevel(int MinLevel, int MaxLevel); void CBag::MakeBagEffectUse(int aIndex, int iMonsterIndex); void CBag::AddCoin(int aIndex); void CBag::DropSummonItem(int aIndex);

f98d81064e9785511198526e85037b0bd24529638acaa11b5a9bc83d53bb19c8

yanesroann

yanesroann

tetris/tetrisboard.cpp

Tetrisboard::getEndgame

bool Tetrisboard::getEndgame() { return endgame; }

Tetrisboard::Tetrisboard(); int Tetrisboard::getx(); int Tetrisboard::gety(); int Tetrisboard::getRed(); int Tetrisboard::getGreen(); int Tetrisboard::getBlue(); int Tetrisboard::getShape(); int Tetrisboard::getOrientation(); void Tetrisboard::setx(int x); void Tetrisboard::sety(int y); void Tetrisboard::setColor(int r, int g, int b); void Tetrisboard::setShape(int s); void Tetrisboard::setOrientation(int o); void Tetrisboard::setEndgame(bool truthvalue); void Tetrisboard::initialize(); void Tetrisboard::drawLines(); void Tetrisboard::displayArray(); void Tetrisboard::addblock(int x, int y); void Tetrisboard::removeblock(int x, int y); void Tetrisboard::fall(); void Tetrisboard::moveLeft(); void Tetrisboard::moveRight(); bool Tetrisboard::openRotate(); void Tetrisboard::rotate(); bool Tetrisboard::checkbelow(); void Tetrisboard::clearLine();

5459133a463e59f0003fe3934834cc840d91acda44ddcaa9ea20cebc850efbc9

Code0100Food

3DEngine

MonoScripting/MonoScripting/test.cpp

SetFieldValue

void SetFieldValue(MonoObject * script, MonoClassField * field, void * input_value) { mono_field_set_value(script, field, input_value); }

const char* MonoScripting::GetDLLPath(); const char* MonoScripting::GetLastError(); bool MonoScripting::InitMono(); bool MonoScripting::CleanUpMono(); MonoDomain * LoadAppDomain(); void UnLoadAppDomain(); bool MonoScripting::CompileFile(const char* input_file, const char* output_file); MonoAssemblyName* MonoScripting::LoadScriptAssembly(const char* assembly_path); bool MonoScripting::UnLoadScriptAssembly(MonoAssemblyName * asm_); MonoObject* MonoScripting::CreateMonoObject(MonoAssemblyName* assembly, const char* class_name, const char* name_space); MonoImage * LoadMonoImage(MonoAssemblyName * asm_); bool MonoScripting::ExecuteMethod(MonoObject* script, const char* method_name); void AddMethodInternalCall(const char * cs_path, const void * method); const char* MonoStringToConstChar(MonoString* string); const char* MonoScripting::GetFieldsNameAndType(MonoObject* script, void** iterator); unsigned int MonoScripting::GetFieldValue(MonoObject* script, const char* field_name, void** output_value); MonoClassField * GetFieldValue(MonoImage * image, const char * namespace_, const char * class_name, const char * field_name); bool MonoScripting::SetFieldValue(MonoObject* script, const char* field_name, void* input_value); int main(int argc, char *argv[]);

a5c0b9766422cf6aab3da44045e710b3b2545d2ba3f47a6da6b2dcf2821e588d

Chuck5ta

Game-server-emulator

src/game/SpellAuras.cpp

Aura::HandleModTaunt

void Aura::HandleModTaunt(bool apply, bool Real) { if (!Real) return; Unit* target = GetTarget(); if (!target->IsAlive() || !target->CanHaveThreatList()) return; Unit* caster = GetCaster(); if (!caster || !caster->IsAlive()) return; if (apply) target->TauntApply(caster); else { target->TauntFadeOut(caster); } }

Aura::Aura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem); Aura::~Aura(); AreaAura::~AreaAura(); PersistentAreaAura::~PersistentAreaAura(); SingleEnemyTargetAura::~SingleEnemyTargetAura(); Unit* SingleEnemyTargetAura::GetTriggerTarget(); Aura* CreateAura(SpellEntry const* spellproto, SpellEffectIndex eff, int32* currentBasePoints, SpellAuraHolder* holder, Unit* target, Unit* caster, Item* castItem); SpellAuraHolder* CreateSpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem); void Aura::SetModifier(AuraType t, int32 a, uint32 pt, int32 miscValue); void Aura::Update(uint32 diff); void AreaAura::Update(uint32 diff); void PersistentAreaAura::Update(uint32 diff); void Aura::ApplyModifier(bool apply, bool Real); bool Aura::isAffectedOnSpell(SpellEntry const* spell); bool Aura::CanProcFrom(SpellEntry const* spell, uint32 /*procFlag*/, uint32 EventProcEx, uint32 procEx, bool active, bool useClassMask); void Aura::ReapplyAffectedPassiveAuras(Unit* target, bool owner_mode); void Aura::ReapplyAffectedPassiveAuras(); void Aura::HandleAddModifier(bool apply, bool Real); void Aura::TriggerSpell(); void Aura::TriggerSpellWithValue(); void Aura::HandleAuraDummy(bool apply, bool Real); void Aura::HandleAuraMounted(bool apply, bool Real); void Aura::HandleAuraWaterWalk(bool apply, bool Real); void Aura::HandleAuraFeatherFall(bool apply, bool Real); void Aura::HandleAuraHover(bool apply, bool Real); void Aura::HandleWaterBreathing(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModShapeshift(bool apply, bool Real); void Aura::HandleAuraTransform(bool apply, bool Real); void Aura::HandleForceReaction(bool apply, bool Real); void Aura::HandleAuraModSkill(bool apply, bool /*Real*/); void Aura::HandleChannelDeathItem(bool apply, bool Real); void Aura::HandleBindSight(bool apply, bool /*Real*/); void Aura::HandleFarSight(bool apply, bool /*Real*/); void Aura::HandleAuraTrackCreatures(bool apply, bool /*Real*/); void Aura::HandleAuraTrackResources(bool apply, bool /*Real*/); void Aura::HandleAuraTrackStealthed(bool apply, bool /*Real*/); void Aura::HandleAuraModScale(bool apply, bool /*Real*/); void Aura::HandleModPossess(bool apply, bool Real); void Aura::HandleModPossessPet(bool apply, bool Real); void Aura::HandleAuraModPetTalentsPoints(bool /*Apply*/, bool Real); void Aura::HandleModCharm(bool apply, bool Real); void Aura::HandleModConfuse(bool apply, bool Real); void Aura::HandleModFear(bool apply, bool Real); void Aura::HandleFeignDeath(bool apply, bool Real); void Aura::HandleAuraModDisarm(bool apply, bool Real); void Aura::HandleAuraModStun(bool apply, bool Real); void Aura::HandleModStealth(bool apply, bool Real); void Aura::HandleInvisibility(bool apply, bool Real); void Aura::HandleInvisibilityDetect(bool apply, bool Real); void Aura::HandleDetectAmore(bool apply, bool /*real*/); void Aura::HandleAuraModRoot(bool apply, bool Real); void Aura::HandleAuraModSilence(bool apply, bool Real); void Aura::HandleModThreat(bool apply, bool Real); void Aura::HandleAuraModTotalThreat(bool apply, bool Real); void Aura::HandleAuraFakeInebriation(bool apply, bool Real); void Aura::HandleAuraModIncreaseSpeed(bool /*apply*/, bool Real); void Aura::HandleAuraModIncreaseMountedSpeed(bool apply, bool Real); void Aura::HandleAuraModIncreaseFlightSpeed(bool apply, bool Real); void Aura::HandleAuraModIncreaseSwimSpeed(bool /*apply*/, bool Real); void Aura::HandleAuraModDecreaseSpeed(bool apply, bool Real); void Aura::HandleAuraModUseNormalSpeed(bool /*apply*/, bool Real); void Aura::HandleModMechanicImmunity(bool apply, bool /*Real*/); void Aura::HandleModMechanicImmunityMask(bool apply, bool /*Real*/); void Aura::HandleAuraModEffectImmunity(bool apply, bool /*Real*/); void Aura::HandleAuraModStateImmunity(bool apply, bool Real); void Aura::HandleAuraModSchoolImmunity(bool apply, bool Real); void Aura::HandleAuraModDmgImmunity(bool apply, bool /*Real*/); void Aura::HandleAuraModDispelImmunity(bool apply, bool Real); void Aura::HandleAuraProcTriggerSpell(bool apply, bool Real); void Aura::HandleAuraModStalked(bool apply, bool /*Real*/); void Aura::HandlePeriodicTriggerSpell(bool apply, bool /*Real*/); void Aura::HandlePeriodicTriggerSpellWithValue(bool apply, bool /*Real*/); void Aura::HandlePeriodicEnergize(bool apply, bool Real); void Aura::HandleAuraPowerBurn(bool apply, bool /*Real*/); void Aura::HandleAuraPeriodicDummy(bool apply, bool Real); void Aura::HandlePeriodicHeal(bool apply, bool /*Real*/); void Aura::HandleDamagePercentTaken(bool apply, bool Real); void Aura::HandlePeriodicDamage(bool apply, bool Real); void Aura::HandlePeriodicDamagePCT(bool apply, bool /*Real*/); void Aura::HandlePeriodicLeech(bool apply, bool /*Real*/); void Aura::HandlePeriodicManaLeech(bool apply, bool /*Real*/); void Aura::HandlePeriodicHealthFunnel(bool apply, bool /*Real*/); void Aura::HandleAuraModResistanceExclusive(bool apply, bool /*Real*/); void Aura::HandleAuraModResistance(bool apply, bool /*Real*/); void Aura::HandleAuraModBaseResistancePCT(bool apply, bool /*Real*/); void Aura::HandleModResistancePercent(bool apply, bool /*Real*/); void Aura::HandleModBaseResistance(bool apply, bool /*Real*/); void Aura::HandleAuraModStat(bool apply, bool /*Real*/); void Aura::HandleModPercentStat(bool apply, bool /*Real*/); void Aura::HandleModSpellDamagePercentFromStat(bool /*apply*/, bool /*Real*/); void Aura::HandleModSpellHealingPercentFromStat(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModDispelResist(bool apply, bool Real); void Aura::HandleModSpellDamagePercentFromAttackPower(bool /*apply*/, bool /*Real*/); void Aura::HandleModSpellHealingPercentFromAttackPower(bool /*apply*/, bool /*Real*/); void Aura::HandleModHealingDone(bool /*apply*/, bool /*Real*/); void Aura::HandleModTotalPercentStat(bool apply, bool /*Real*/); void Aura::HandleAuraModResistenceOfStatPercent(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModTotalHealthPercentRegen(bool apply, bool /*Real*/); void Aura::HandleAuraModTotalManaPercentRegen(bool apply, bool /*Real*/); void Aura::HandleModRegen(bool apply, bool /*Real*/); void Aura::HandleModPowerRegen(bool apply, bool Real); void Aura::HandleModPowerRegenPCT(bool /*apply*/, bool Real); void Aura::HandleModManaRegen(bool /*apply*/, bool Real); void Aura::HandleComprehendLanguage(bool apply, bool /*Real*/); void Aura::HandleAuraModIncreaseHealth(bool apply, bool Real); void Aura::HandleAuraModIncreaseMaxHealth(bool apply, bool /*Real*/); void Aura::HandleAuraModIncreaseEnergy(bool apply, bool Real); void Aura::HandleAuraModIncreaseEnergyPercent(bool apply, bool /*Real*/); void Aura::HandleAuraModIncreaseHealthPercent(bool apply, bool /*Real*/); void Aura::HandleAuraIncreaseBaseHealthPercent(bool apply, bool /*Real*/); void Aura::HandleAuraModParryPercent(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModDodgePercent(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModBlockChancePercent(bool /*apply*/, bool /*Real*/); void Aura::HandleAuraModRegenInterrupt(bool /*apply*/, bool Real); void Aura::HandleAuraModCritPercent(bool apply, bool Real); void Aura::HandleModHitChance(bool apply, bool /*Real*/); void Aura::HandleModSpellHitChance(bool apply, bool /*Real*/); void Aura::HandleModSpellCritChance(bool apply, bool Real); void Aura::HandleModSpellCritChanceShool(bool /*apply*/, bool Real); void Aura::HandleModCastingSpeed(bool apply, bool /*Real*/); void Aura::HandleModMeleeRangedSpeedPct(bool apply, bool /*Real*/); void Aura::HandleModCombatSpeedPct(bool apply, bool /*Real*/); void Aura::HandleModAttackSpeed(bool apply, bool /*Real*/); void Aura::HandleModMeleeSpeedPct(bool apply, bool /*Real*/); void Aura::HandleAuraModRangedHaste(bool apply, bool /*Real*/); void Aura::HandleRangedAmmoHaste(bool apply, bool /*Real*/); void Aura::HandleAuraModAttackPower(bool apply, bool /*Real*/); void Aura::HandleAuraModRangedAttackPower(bool apply, bool /*Real*/); void Aura::HandleAuraModAttackPowerPercent(bool apply, bool /*Real*/); void Aura::HandleAuraModRangedAttackPowerPercent(bool apply, bool /*Real*/); void Aura::HandleAuraModAttackPowerOfArmor(bool /*apply*/, bool Real); void Aura::HandleModDamageDone(bool apply, bool Real); void Aura::HandleModDamagePercentDone(bool apply, bool Real); void Aura::HandleModOffhandDamagePercent(bool apply, bool Real); void Aura::HandleModPowerCostPCT(bool apply, bool Real); void Aura::HandleModPowerCost(bool apply, bool Real); void Aura::HandleNoReagentUseAura(bool /*Apply*/, bool Real); void Aura::HandleShapeshiftBoosts(bool apply); void Aura::HandleAuraEmpathy(bool apply, bool /*Real*/); void Aura::HandleAuraUntrackable(bool apply, bool /*Real*/); void Aura::HandleAuraModPacify(bool apply, bool /*Real*/); void Aura::HandleAuraModPacifyAndSilence(bool apply, bool Real); void Aura::HandleAuraGhost(bool apply, bool /*Real*/); void Aura::HandleAuraAllowFlight(bool apply, bool Real); void Aura::HandleModRating(bool apply, bool Real); void Aura::HandleModRatingFromStat(bool apply, bool Real); void Aura::HandleForceMoveForward(bool apply, bool Real); void Aura::HandleAuraModExpertise(bool /*apply*/, bool /*Real*/); void Aura::HandleModTargetResistance(bool apply, bool Real); void Aura::HandleModShieldBlockDamage(bool apply, bool /*Real*/); void Aura::HandleAuraRetainComboPoints(bool apply, bool Real); void Aura::HandleModUnattackable(bool Apply, bool Real); void Aura::HandleSpiritOfRedemption(bool apply, bool Real); void Aura::HandleSchoolAbsorb(bool apply, bool Real); void Aura::PeriodicTick(); void Aura::PeriodicDummyTick(); void Aura::HandlePreventFleeing(bool apply, bool Real); void Aura::HandleManaShield(bool apply, bool Real); void Aura::HandleArenaPreparation(bool apply, bool Real); void Aura::HandleAuraControlVehicle(bool apply, bool Real); void Aura::HandleAuraAddMechanicAbilities(bool apply, bool Real); void Aura::HandleAuraOpenStable(bool apply, bool Real); void Aura::HandleAuraMirrorImage(bool apply, bool Real); void Aura::HandleAuraConvertRune(bool apply, bool Real); void Aura::HandlePhase(bool apply, bool Real); void Aura::HandleAuraSafeFall(bool Apply, bool Real); bool Aura::IsCritFromAbilityAura(Unit* caster, uint32& damage); void Aura::HandleAuraModAllCritChance(bool apply, bool Real); void Aura::HandleAuraStopNaturalManaRegen(bool apply, bool Real); void Aura::HandleAuraSetVehicleId(bool apply, bool Real); void Aura::HandleAuraMastery(bool apply, bool Real); void Aura::HandleAuraModBlockCritChance(bool apply, bool Real); bool Aura::IsLastAuraOnHolder(); bool Aura::HasMechanic(uint32 mechanic); SpellAuraHolder::SpellAuraHolder(SpellEntry const* spellproto, Unit* target, WorldObject* caster, Item* castItem); void SpellAuraHolder::AddAura(Aura* aura, SpellEffectIndex index); void SpellAuraHolder::RemoveAura(SpellEffectIndex index); void SpellAuraHolder::ApplyAuraModifiers(bool apply, bool real); void SpellAuraHolder::_AddSpellAuraHolder(); void SpellAuraHolder::_RemoveSpellAuraHolder(); void SpellAuraHolder::CleanupTriggeredSpells(); bool SpellAuraHolder::ModStackAmount(int32 num); void SpellAuraHolder::SetStackAmount(uint32 stackAmount); Unit* SpellAuraHolder::GetCaster(); bool SpellAuraHolder::IsWeaponBuffCoexistableWith(SpellAuraHolder const* ref); bool SpellAuraHolder::IsNeedVisibleSlot(Unit const* caster); void SpellAuraHolder::BuildUpdatePacket(WorldPacket& data); void SpellAuraHolder::SendAuraUpdate(bool remove); void SpellAuraHolder::HandleSpellSpecificBoosts(bool apply); SpellAuraHolder::~SpellAuraHolder(); void SpellAuraHolder::Update(uint32 diff); void SpellAuraHolder::RefreshHolder(); void SpellAuraHolder::SetAuraMaxDuration(int32 duration); bool SpellAuraHolder::HasMechanic(uint32 mechanic); bool SpellAuraHolder::HasMechanicMask(uint32 mechanicMask); bool SpellAuraHolder::IsPersistent(); bool SpellAuraHolder::IsAreaAura(); bool SpellAuraHolder::IsPositive(); bool SpellAuraHolder::IsEmptyHolder(); void SpellAuraHolder::UnregisterAndCleanupTrackedAuras(); void Aura::HandleModIncreaseSpellPowerPct(bool apply, bool Real); void Aura::HandleOverrideSpellPowerByAp(bool apply, bool Real);

e1a50881c9664f921cf3b3a8b1c7d335c81506afc1546fdc76964b2f03abddda

pixelpicosean

my-godot-2.1

servers/visual/visual_server_raster.cpp

VisualServerRaster::camera_create

RID VisualServerRaster::camera_create() { Camera *camera = memnew(Camera); return camera_owner.make_rid(camera); }

RID VisualServerRaster::texture_create(); void VisualServerRaster::texture_allocate(RID p_texture, int p_width, int p_height, Image::Format p_format, uint32_t p_flags); void VisualServerRaster::texture_set_flags(RID p_texture, uint32_t p_flags); void VisualServerRaster::texture_set_data(RID p_texture, const Image &p_image, CubeMapSide p_cube_side); Image VisualServerRaster::texture_get_data(RID p_texture, CubeMapSide p_cube_side); uint32_t VisualServerRaster::texture_get_flags(RID p_texture); Image::Format VisualServerRaster::texture_get_format(RID p_texture); uint32_t VisualServerRaster::texture_get_width(RID p_texture); uint32_t VisualServerRaster::texture_get_height(RID p_texture); void VisualServerRaster::texture_set_size_override(RID p_texture, int p_width, int p_height); bool VisualServerRaster::texture_can_stream(RID p_texture); void VisualServerRaster::texture_set_reload_hook(RID p_texture, ObjectID p_owner, const StringName &p_function); void VisualServerRaster::texture_set_path(RID p_texture, const String &p_path); String VisualServerRaster::texture_get_path(RID p_texture); void VisualServerRaster::texture_debug_usage(List<TextureInfo> *r_info); void VisualServerRaster::texture_set_shrink_all_x2_on_set_data(bool p_enable); RID VisualServerRaster::shader_create(ShaderMode p_mode); void VisualServerRaster::shader_set_mode(RID p_shader, ShaderMode p_mode); VisualServer::ShaderMode VisualServerRaster::shader_get_mode(RID p_shader); void VisualServerRaster::shader_set_code(RID p_shader, const String &p_vertex, const String &p_fragment, const String &p_light, int p_vertex_ofs, int p_fragment_ofs, int p_light_ofs); String VisualServerRaster::shader_get_vertex_code(RID p_shader); String VisualServerRaster::shader_get_fragment_code(RID p_shader); String VisualServerRaster::shader_get_light_code(RID p_shader); void VisualServerRaster::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list); void VisualServerRaster::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture); RID VisualServerRaster::shader_get_default_texture_param(RID p_shader, const StringName &p_name); RID VisualServerRaster::material_create(); void VisualServerRaster::material_set_shader(RID p_material, RID p_shader); RID VisualServerRaster::material_get_shader(RID p_material); void VisualServerRaster::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value); Variant VisualServerRaster::material_get_param(RID p_material, const StringName &p_param); void VisualServerRaster::material_set_flag(RID p_material, MaterialFlag p_flag, bool p_enabled); void VisualServerRaster::material_set_depth_draw_mode(RID p_material, MaterialDepthDrawMode p_mode); VS::MaterialDepthDrawMode VisualServerRaster::material_get_depth_draw_mode(RID p_material); bool VisualServerRaster::material_get_flag(RID p_material, MaterialFlag p_flag); void VisualServerRaster::material_set_blend_mode(RID p_material, MaterialBlendMode p_mode); VS::MaterialBlendMode VisualServerRaster::material_get_blend_mode(RID p_material); void VisualServerRaster::material_set_line_width(RID p_material, float p_line_width); float VisualServerRaster::material_get_line_width(RID p_material); RID VisualServerRaster::fixed_material_create(); void VisualServerRaster::fixed_material_set_flag(RID p_material, FixedMaterialFlags p_flag, bool p_enabled); bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag); void VisualServerRaster::fixed_material_set_param(RID p_material, FixedMaterialParam p_parameter, const Variant &p_value); Variant VisualServerRaster::fixed_material_get_param(RID p_material, FixedMaterialParam p_parameter); void VisualServerRaster::fixed_material_set_texture(RID p_material, FixedMaterialParam p_parameter, RID p_texture); RID VisualServerRaster::fixed_material_get_texture(RID p_material, FixedMaterialParam p_parameter); void VisualServerRaster::fixed_material_set_texcoord_mode(RID p_material, FixedMaterialParam p_parameter, FixedMaterialTexCoordMode p_mode); VS::FixedMaterialTexCoordMode VisualServerRaster::fixed_material_get_texcoord_mode(RID p_material, FixedMaterialParam p_parameter); void VisualServerRaster::fixed_material_set_point_size(RID p_material, float p_size); float VisualServerRaster::fixed_material_get_point_size(RID p_material); void VisualServerRaster::fixed_material_set_uv_transform(RID p_material, const Transform &p_transform); Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material); void VisualServerRaster::fixed_material_set_light_shader(RID p_material, FixedMaterialLightShader p_shader); VisualServerRaster::FixedMaterialLightShader VisualServerRaster::fixed_material_get_light_shader(RID p_material); RID VisualServerRaster::mesh_create(); void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh, int p_amount); int VisualServerRaster::mesh_get_morph_target_count(RID p_mesh); void VisualServerRaster::mesh_set_morph_target_mode(RID p_mesh, MorphTargetMode p_mode); VisualServer::MorphTargetMode VisualServerRaster::mesh_get_morph_target_mode(RID p_mesh); void VisualServerRaster::mesh_add_custom_surface(RID p_mesh, const Variant &p_dat); void VisualServerRaster::mesh_add_surface(RID p_mesh, PrimitiveType p_primitive, const Array &p_arrays, const Array &p_blend_shapes, bool p_alpha_sort); Array VisualServerRaster::mesh_get_surface_arrays(RID p_mesh, int p_surface); Array VisualServerRaster::mesh_get_surface_morph_arrays(RID p_mesh, int p_surface); void VisualServerRaster::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material, bool p_owned); RID VisualServerRaster::mesh_surface_get_material(RID p_mesh, int p_surface); int VisualServerRaster::mesh_surface_get_array_len(RID p_mesh, int p_surface); int VisualServerRaster::mesh_surface_get_array_index_len(RID p_mesh, int p_surface); uint32_t VisualServerRaster::mesh_surface_get_format(RID p_mesh, int p_surface); VisualServer::PrimitiveType VisualServerRaster::mesh_surface_get_primitive_type(RID p_mesh, int p_surface); void VisualServerRaster::mesh_remove_surface(RID p_mesh, int p_surface); int VisualServerRaster::mesh_get_surface_count(RID p_mesh); void VisualServerRaster::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb); AABB VisualServerRaster::mesh_get_custom_aabb(RID p_mesh); void VisualServerRaster::mesh_clear(RID p_mesh); RID VisualServerRaster::multimesh_create(); void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh, int p_count); int VisualServerRaster::multimesh_get_instance_count(RID p_multimesh); void VisualServerRaster::multimesh_set_mesh(RID p_multimesh, RID p_mesh); void VisualServerRaster::multimesh_set_aabb(RID p_multimesh, const AABB &p_aabb); void VisualServerRaster::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform); void VisualServerRaster::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color); RID VisualServerRaster::multimesh_get_mesh(RID p_multimesh); AABB VisualServerRaster::multimesh_get_aabb(RID p_multimesh, const AABB &p_aabb); Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh, int p_index); Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh, int p_index); void VisualServerRaster::multimesh_set_visible_instances(RID p_multimesh, int p_visible); int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh); RID VisualServerRaster::immediate_create(); void VisualServerRaster::immediate_begin(RID p_immediate, PrimitiveType p_primitive, RID p_texture); void VisualServerRaster::immediate_vertex(RID p_immediate, const Vector3 &p_vertex); void VisualServerRaster::immediate_normal(RID p_immediate, const Vector3 &p_normal); void VisualServerRaster::immediate_tangent(RID p_immediate, const Plane &p_tangent); void VisualServerRaster::immediate_color(RID p_immediate, const Color &p_color); void VisualServerRaster::immediate_uv(RID p_immediate, const Vector2 &p_uv); void VisualServerRaster::immediate_uv2(RID p_immediate, const Vector2 &p_uv2); void VisualServerRaster::immediate_end(RID p_immediate); void VisualServerRaster::immediate_clear(RID p_immediate); void VisualServerRaster::immediate_set_material(RID p_immediate, RID p_material); RID VisualServerRaster::immediate_get_material(RID p_immediate); RID VisualServerRaster::particles_create(); void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount); int VisualServerRaster::particles_get_amount(RID p_particles); void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting); bool VisualServerRaster::particles_is_emitting(RID p_particles); void VisualServerRaster::particles_set_visibility_aabb(RID p_particles, const AABB &p_visibility); AABB VisualServerRaster::particles_get_visibility_aabb(RID p_particles); void VisualServerRaster::particles_set_emission_half_extents(RID p_particles, const Vector3 &p_half_extents); Vector3 VisualServerRaster::particles_get_emission_half_extents(RID p_particles); void VisualServerRaster::particles_set_emission_base_velocity(RID p_particles, const Vector3 &p_base_velocity); Vector3 VisualServerRaster::particles_get_emission_base_velocity(RID p_particles); void VisualServerRaster::particles_set_emission_points(RID p_particles, const DVector<Vector3> &p_points); DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles); void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3 &p_normal); Vector3 VisualServerRaster::particles_get_gravity_normal(RID p_particles); void VisualServerRaster::particles_set_variable(RID p_particles, ParticleVariable p_variable, float p_value); float VisualServerRaster::particles_get_variable(RID p_particles, ParticleVariable p_variable); void VisualServerRaster::particles_set_randomness(RID p_particles, ParticleVariable p_variable, float p_randomness); float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable); void VisualServerRaster::particles_set_color_phases(RID p_particles, int p_phases); int VisualServerRaster::particles_get_color_phases(RID p_particles); void VisualServerRaster::particles_set_color_phase_pos(RID p_particles, int p_phase, float p_pos); float VisualServerRaster::particles_get_color_phase_pos(RID p_particles, int p_phase); void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors); int VisualServerRaster::particles_get_attractors(RID p_particles); void VisualServerRaster::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3 &p_pos); Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles, int p_attractor); void VisualServerRaster::particles_set_attractor_strength(RID p_particles, int p_attractor, float p_force); float VisualServerRaster::particles_get_attractor_strength(RID p_particles, int p_attractor); void VisualServerRaster::particles_set_color_phase_color(RID p_particles, int p_phase, const Color &p_color); Color VisualServerRaster::particles_get_color_phase_color(RID p_particles, int p_phase); void VisualServerRaster::particles_set_material(RID p_particles, RID p_material, bool p_owned); RID VisualServerRaster::particles_get_material(RID p_particles); void VisualServerRaster::particles_set_height_from_velocity(RID p_particles, bool p_enable); bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles); void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable); bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles); RID VisualServerRaster::light_create(LightType p_type); VisualServer::LightType VisualServerRaster::light_get_type(RID p_light); void VisualServerRaster::light_set_color(RID p_light, LightColor p_type, const Color &p_color); Color VisualServerRaster::light_get_color(RID p_light, LightColor p_type); void VisualServerRaster::light_set_shadow(RID p_light, bool p_enabled); bool VisualServerRaster::light_has_shadow(RID p_light); void VisualServerRaster::light_set_volumetric(RID p_light, bool p_enabled); bool VisualServerRaster::light_is_volumetric(RID p_light); void VisualServerRaster::light_set_projector(RID p_light, RID p_texture); RID VisualServerRaster::light_get_projector(RID p_light); void VisualServerRaster::light_set_param(RID p_light, LightParam p_var, float p_value); float VisualServerRaster::light_get_param(RID p_light, LightParam p_var); void VisualServerRaster::light_set_operator(RID p_light, LightOp p_op); VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light); void VisualServerRaster::light_omni_set_shadow_mode(RID p_light, LightOmniShadowMode p_mode); VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light); void VisualServerRaster::light_directional_set_shadow_mode(RID p_light, LightDirectionalShadowMode p_mode); VS::LightDirectionalShadowMode VisualServerRaster::light_directional_get_shadow_mode(RID p_light); void VisualServerRaster::light_directional_set_shadow_param(RID p_light, LightDirectionalShadowParam p_param, float p_value); float VisualServerRaster::light_directional_get_shadow_param(RID p_light, LightDirectionalShadowParam p_param); RID VisualServerRaster::skeleton_create(); void VisualServerRaster::skeleton_resize(RID p_skeleton, int p_bones); int VisualServerRaster::skeleton_get_bone_count(RID p_skeleton); void VisualServerRaster::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform); Transform VisualServerRaster::skeleton_bone_get_transform(RID p_skeleton, int p_bone); RID VisualServerRaster::room_create(); void VisualServerRaster::room_set_bounds(RID p_room, const BSP_Tree &p_bounds); BSP_Tree VisualServerRaster::room_get_bounds(RID p_room); RID VisualServerRaster::portal_create(); void VisualServerRaster::portal_set_shape(RID p_portal, const Vector<Point2> &p_shape); Vector<Point2> VisualServerRaster::portal_get_shape(RID p_portal); void VisualServerRaster::portal_set_enabled(RID p_portal, bool p_enabled); bool VisualServerRaster::portal_is_enabled(RID p_portal); void VisualServerRaster::portal_set_disable_distance(RID p_portal, float p_distance); float VisualServerRaster::portal_get_disable_distance(RID p_portal); void VisualServerRaster::portal_set_disabled_color(RID p_portal, const Color &p_color); Color VisualServerRaster::portal_get_disabled_color(RID p_portal); void VisualServerRaster::portal_set_connect_range(RID p_portal, float p_range); float VisualServerRaster::portal_get_connect_range(RID p_portal); RID VisualServerRaster::baked_light_create(); void VisualServerRaster::baked_light_set_mode(RID p_baked_light, BakedLightMode p_mode); VisualServer::BakedLightMode VisualServerRaster::baked_light_get_mode(RID p_baked_light); void VisualServerRaster::baked_light_set_lightmap_multiplier(RID p_baked_light, float p_multiplier); float VisualServerRaster::baked_light_get_lightmap_multiplier(RID p_baked_light); void VisualServerRaster::baked_light_set_octree(RID p_baked_light, const DVector<uint8_t> p_octree); DVector<uint8_t> VisualServerRaster::baked_light_get_octree(RID p_baked_light); void VisualServerRaster::baked_light_set_light(RID p_baked_light, const DVector<uint8_t> p_light); DVector<uint8_t> VisualServerRaster::baked_light_get_light(RID p_baked_light); void VisualServerRaster::baked_light_set_sampler_octree(RID p_baked_light, const DVector<int> &p_sampler); DVector<int> VisualServerRaster::baked_light_get_sampler_octree(RID p_baked_light); void VisualServerRaster::baked_light_add_lightmap(RID p_baked_light, const RID p_texture, int p_id); void VisualServerRaster::baked_light_clear_lightmaps(RID p_baked_light); void VisualServerRaster::baked_light_set_realtime_color_enabled(RID p_baked_light, const bool p_enabled); bool VisualServerRaster::baked_light_get_realtime_color_enabled(RID p_baked_light); void VisualServerRaster::baked_light_set_realtime_color(RID p_baked_light, const Color &p_color); Color VisualServerRaster::baked_light_get_realtime_color(RID p_baked_light); void VisualServerRaster::baked_light_set_realtime_energy(RID p_baked_light, const float p_energy); float VisualServerRaster::baked_light_get_realtime_energy(RID p_baked_light); RID VisualServerRaster::baked_light_sampler_create(); void VisualServerRaster::baked_light_sampler_set_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param, float p_value); float VisualServerRaster::baked_light_sampler_get_param(RID p_baked_light_sampler, BakedLightSamplerParam p_param); void VisualServerRaster::_update_baked_light_sampler_dp_cache(BakedLightSampler *blsamp); void VisualServerRaster::baked_light_sampler_set_resolution(RID p_baked_light_sampler, int p_resolution); int VisualServerRaster::baked_light_sampler_get_resolution(RID p_baked_light_sampler); void VisualServerRaster::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far); void VisualServerRaster::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far); void VisualServerRaster::camera_set_transform(RID p_camera, const Transform &p_transform); void VisualServerRaster::camera_set_visible_layers(RID p_camera, uint32_t p_layers); uint32_t VisualServerRaster::camera_get_visible_layers(RID p_camera); void VisualServerRaster::camera_set_environment(RID p_camera, RID p_env); RID VisualServerRaster::camera_get_environment(RID p_camera); void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera, bool p_enable); bool VisualServerRaster::camera_is_using_vertical_aspect(RID p_camera, bool p_enable); RID VisualServerRaster::viewport_create(); void VisualServerRaster::viewport_attach_to_screen(RID p_viewport, int p_screen); void VisualServerRaster::viewport_detach(RID p_viewport); void VisualServerRaster::viewport_set_as_render_target(RID p_viewport, bool p_enable); void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport, RenderTargetUpdateMode p_mode); VisualServer::RenderTargetUpdateMode VisualServerRaster::viewport_get_render_target_update_mode(RID p_viewport); RID VisualServerRaster::viewport_get_render_target_texture(RID p_viewport); void VisualServerRaster::viewport_set_render_target_vflip(RID p_viewport, bool p_enable); void VisualServerRaster::viewport_set_render_target_clear_on_new_frame(RID p_viewport, bool p_enable); void VisualServerRaster::viewport_set_render_target_to_screen_rect(RID p_viewport, const Rect2 &p_rect); bool VisualServerRaster::viewport_get_render_target_vflip(RID p_viewport); bool VisualServerRaster::viewport_get_render_target_clear_on_new_frame(RID p_viewport); void VisualServerRaster::viewport_render_target_clear(RID p_viewport); void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport); Image VisualServerRaster::viewport_get_screen_capture(RID p_viewport); void VisualServerRaster::viewport_set_rect(RID p_viewport, const ViewportRect &p_rect); VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport); void VisualServerRaster::viewport_set_hide_scenario(RID p_viewport, bool p_hide); void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport, bool p_hide); void VisualServerRaster::viewport_set_disable_environment(RID p_viewport, bool p_disable); void VisualServerRaster::viewport_attach_camera(RID p_viewport, RID p_camera); void VisualServerRaster::viewport_set_scenario(RID p_viewport, RID p_scenario); RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport); void VisualServerRaster::viewport_attach_canvas(RID p_viewport, RID p_canvas); void VisualServerRaster::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Matrix32 &p_transform); Matrix32 VisualServerRaster::viewport_get_canvas_transform(RID p_viewport, RID p_canvas); void VisualServerRaster::viewport_set_global_canvas_transform(RID p_viewport, const Matrix32 &p_transform); Matrix32 VisualServerRaster::viewport_get_global_canvas_transform(RID p_viewport); void VisualServerRaster::viewport_remove_canvas(RID p_viewport, RID p_canvas); void VisualServerRaster::viewport_set_canvas_layer(RID p_viewport, RID p_canvas, int p_layer); void VisualServerRaster::viewport_set_transparent_background(RID p_viewport, bool p_enabled); bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport); RID VisualServerRaster::viewport_get_scenario(RID p_viewport); RID VisualServerRaster::environment_create(); void VisualServerRaster::environment_set_background(RID p_env, EnvironmentBG p_bg); VisualServer::EnvironmentBG VisualServerRaster::environment_get_background(RID p_env); void VisualServerRaster::environment_set_background_param(RID p_env, EnvironmentBGParam p_param, const Variant &p_value); Variant VisualServerRaster::environment_get_background_param(RID p_env, EnvironmentBGParam p_param); void VisualServerRaster::environment_set_enable_fx(RID p_env, EnvironmentFx p_effect, bool p_enabled); bool VisualServerRaster::environment_is_fx_enabled(RID p_env, EnvironmentFx p_effect); void VisualServerRaster::environment_fx_set_param(RID p_env, EnvironmentFxParam p_param, const Variant &p_value); Variant VisualServerRaster::environment_fx_get_param(RID p_env, EnvironmentFxParam p_param); void VisualServerRaster::_dependency_queue_update(RID p_rid, bool p_update_aabb, bool p_update_materials); void VisualServerRaster::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_materials); RID VisualServerRaster::scenario_create(); void VisualServerRaster::scenario_set_debug(RID p_scenario, ScenarioDebugMode p_debug_mode); void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment); void VisualServerRaster::scenario_set_fallback_environment(RID p_scenario, RID p_environment); RID VisualServerRaster::scenario_get_environment(RID p_scenario, RID p_environment); RID VisualServerRaster::instance_create(); void VisualServerRaster::instance_set_base(RID p_instance, RID p_base); RID VisualServerRaster::instance_get_base(RID p_instance); void VisualServerRaster::instance_set_scenario(RID p_instance, RID p_scenario); RID VisualServerRaster::instance_get_scenario(RID p_instance); void VisualServerRaster::instance_set_layer_mask(RID p_instance, uint32_t p_mask); uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance); AABB VisualServerRaster::instance_get_base_aabb(RID p_instance); void VisualServerRaster::instance_attach_object_instance_ID(RID p_instance, uint32_t p_ID); uint32_t VisualServerRaster::instance_get_object_instance_ID(RID p_instance); void VisualServerRaster::instance_attach_skeleton(RID p_instance, RID p_skeleton); RID VisualServerRaster::instance_get_skeleton(RID p_instance); void VisualServerRaster::instance_set_morph_target_weight(RID p_instance, int p_shape, float p_weight); float VisualServerRaster::instance_get_morph_target_weight(RID p_instance, int p_shape); void VisualServerRaster::instance_set_surface_material(RID p_instance, int p_surface, RID p_material); void VisualServerRaster::instance_set_transform(RID p_instance, const Transform &p_transform); Transform VisualServerRaster::instance_get_transform(RID p_instance); void VisualServerRaster::instance_set_exterior(RID p_instance, bool p_enabled); bool VisualServerRaster::instance_is_exterior(RID p_instance); void VisualServerRaster::instance_set_room(RID p_instance, RID p_room); RID VisualServerRaster::instance_get_room(RID p_instance); void VisualServerRaster::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin); real_t VisualServerRaster::instance_get_extra_visibility_margin(RID p_instance); Vector<RID> VisualServerRaster::instances_cull_aabb(const AABB &p_aabb, RID p_scenario); Vector<RID> VisualServerRaster::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario); Vector<RID> VisualServerRaster::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario); void VisualServerRaster::instance_geometry_set_flag(RID p_instance, InstanceFlags p_flags, bool p_enabled); bool VisualServerRaster::instance_geometry_get_flag(RID p_instance, InstanceFlags p_flags); void VisualServerRaster::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting); VS::ShadowCastingSetting VisualServerRaster::instance_geometry_get_cast_shadows_setting(RID p_instance); void VisualServerRaster::instance_geometry_set_material_override(RID p_instance, RID p_material); RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance); void VisualServerRaster::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max); float VisualServerRaster::instance_geometry_get_draw_range_min(RID p_instance); float VisualServerRaster::instance_geometry_get_draw_range_max(RID p_instance); void VisualServerRaster::instance_geometry_set_baked_light(RID p_instance, RID p_baked_light); RID VisualServerRaster::instance_geometry_get_baked_light(RID p_instance); void VisualServerRaster::instance_geometry_set_baked_light_sampler(RID p_instance, RID p_baked_light_sampler); RID VisualServerRaster::instance_geometry_get_baked_light_sampler(RID p_instance); void VisualServerRaster::instance_geometry_set_baked_light_texture_index(RID p_instance, int p_tex_id); int VisualServerRaster::instance_geometry_get_baked_light_texture_index(RID p_instance); void VisualServerRaster::_update_instance(Instance *p_instance); void VisualServerRaster::_update_instance_aabb(Instance *p_instance); void VisualServerRaster::_update_instances(); void VisualServerRaster::instance_light_set_enabled(RID p_instance, bool p_enabled); bool VisualServerRaster::instance_light_is_enabled(RID p_instance); RID VisualServerRaster::canvas_create(); void VisualServerRaster::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring); Point2 VisualServerRaster::canvas_get_item_mirroring(RID p_canvas, RID p_item); void VisualServerRaster::canvas_set_modulate(RID p_canvas, const Color &p_color); RID VisualServerRaster::canvas_item_create(); void VisualServerRaster::canvas_item_set_parent(RID p_item, RID p_parent); RID VisualServerRaster::canvas_item_get_parent(RID p_canvas_item); void VisualServerRaster::canvas_item_set_visible(RID p_item, bool p_visible); bool VisualServerRaster::canvas_item_is_visible(RID p_item); void VisualServerRaster::canvas_item_set_light_mask(RID p_canvas_item, int p_mask); void VisualServerRaster::canvas_item_set_blend_mode(RID p_canvas_item, MaterialBlendMode p_blend); void VisualServerRaster::canvas_item_attach_viewport(RID p_canvas_item, RID p_viewport); void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip); void VisualServerRaster::canvas_item_set_distance_field_mode(RID p_item, bool p_distance_field); void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32 &p_transform); void VisualServerRaster::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect); void VisualServerRaster::canvas_item_set_opacity(RID p_item, float p_opacity); float VisualServerRaster::canvas_item_get_opacity(RID p_item, float p_opacity); void VisualServerRaster::canvas_item_set_on_top(RID p_item, bool p_on_top); bool VisualServerRaster::canvas_item_is_on_top(RID p_item); void VisualServerRaster::canvas_item_set_self_opacity(RID p_item, float p_self_opacity); float VisualServerRaster::canvas_item_get_self_opacity(RID p_item, float p_self_opacity); void VisualServerRaster::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width); void VisualServerRaster::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color); void VisualServerRaster::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color); void VisualServerRaster::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose); void VisualServerRaster::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose); void VisualServerRaster::canvas_item_add_style_box(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, bool p_draw_center, const Color &p_modulate); void VisualServerRaster::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width); void VisualServerRaster::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture); void VisualServerRaster::canvas_item_add_triangle_array_ptr(RID p_item, int p_count, const int *p_indices, const Point2 *p_points, const Color *p_colors, const Point2 *p_uvs, RID p_texture); void VisualServerRaster::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, int p_count); void VisualServerRaster::canvas_item_add_set_transform(RID p_item, const Matrix32 &p_transform); void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend); void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z); void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable); void VisualServerRaster::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect); void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable); void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material); void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable); void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore); void VisualServerRaster::canvas_item_clear(RID p_item); void VisualServerRaster::canvas_item_raise(RID p_item); RID VisualServerRaster::canvas_light_create(); void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light, RID p_canvas); void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled); void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32 &p_transform); void VisualServerRaster::canvas_light_set_scale(RID p_light, float p_scale); void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture); void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset); void VisualServerRaster::canvas_light_set_color(RID p_light, const Color &p_color); void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height); void VisualServerRaster::canvas_light_set_energy(RID p_light, float p_energy); void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z); void VisualServerRaster::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer); void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask); void VisualServerRaster::canvas_light_set_item_shadow_mask(RID p_light, int p_mask); void VisualServerRaster::canvas_light_set_mode(RID p_light, CanvasLightMode p_mode); void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled); void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size); void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier); void VisualServerRaster::canvas_light_set_shadow_color(RID p_light, const Color &p_color); RID VisualServerRaster::canvas_light_occluder_create(); void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas); void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled); void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon); void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder, const Matrix32 &p_xform); void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask); RID VisualServerRaster::canvas_occluder_polygon_create(); void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2> &p_shape, bool p_close); void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const DVector<Vector2> &p_shape); void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, CanvasOccluderPolygonCullMode p_mode); RID VisualServerRaster::canvas_item_material_create(); void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader); void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName &p_param, const Variant &p_value); Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName &p_param); void VisualServerRaster::canvas_item_material_set_shading_mode(RID p_material, CanvasItemShadingMode p_mode); void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor); void VisualServerRaster::cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor, const Rect2 &p_region); void VisualServerRaster::cursor_set_visible(bool p_visible, int p_cursor); void VisualServerRaster::cursor_set_pos(const Point2 &p_pos, int p_cursor); void VisualServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom); void VisualServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom); void VisualServerRaster::_free_attached_instances(RID p_rid, bool p_free_scenario); void VisualServerRaster::custom_shade_model_set_shader(int p_model, RID p_shader); RID VisualServerRaster::custom_shade_model_get_shader(int p_model); void VisualServerRaster::custom_shade_model_set_name(int p_model, const String &p_name); String VisualServerRaster::custom_shade_model_get_name(int p_model); void VisualServerRaster::custom_shade_model_set_param_info(int p_model, const List<PropertyInfo> &p_info); void VisualServerRaster::custom_shade_model_get_param_info(int p_model, List<PropertyInfo> *p_info); void VisualServerRaster::free(RID p_rid); void VisualServerRaster::_instance_draw(Instance *p_instance); Vector<Vector3> VisualServerRaster::_camera_generate_endpoints(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max); Vector<Plane> VisualServerRaster::_camera_generate_orthogonal_planes(Instance *p_light, Camera *p_camera, float p_range_min, float p_range_max); void VisualServerRaster::_light_instance_update_pssm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range); CameraMatrix _lispm_look(const Vector3 pos, const Vector3 dir, const Vector3 up); void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range); void VisualServerRaster::_light_instance_update_lispsm_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range); void VisualServerRaster::_light_instance_update_shadow(Instance *p_light, Scenario *p_scenario, Camera *p_camera, const CullRange &p_cull_range); void VisualServerRaster::_portal_disconnect(Instance *p_portal, bool p_cleanup); void VisualServerRaster::_instance_validate_autorooms(Instance *p_geometry); void VisualServerRaster::_portal_attempt_connect(Instance *p_portal); void *VisualServerRaster::instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int); void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *); bool VisualServerRaster::_test_portal_cull(Camera *p_camera, Instance *p_from_portal, Instance *p_to_portal); void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal, Instance *p_from_portal); void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room, Instance *p_from_portal); void VisualServerRaster::_process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace); void VisualServerRaster::_render_no_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario); void VisualServerRaster::_render_camera(Viewport *p_viewport, Camera *p_camera, Scenario *p_scenario); void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights); void VisualServerRaster::_render_canvas_item_viewport(VisualServer *p_self, void *p_vp, const Rect2 &p_rect); void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item, const Matrix32 &p_transform, const Rect2 &p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner); void VisualServerRaster::_light_mask_canvas_items(int p_z, Rasterizer::CanvasItem *p_canvas_item, Rasterizer::CanvasLight *p_masked_lights); void VisualServerRaster::_render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights, Rasterizer::CanvasLight *p_masked_lights); void VisualServerRaster::_draw_viewport_camera(Viewport *p_viewport, bool p_ignore_camera); void VisualServerRaster::_draw_viewport(Viewport *p_viewport, int p_ofs_x, int p_ofs_y, int p_parent_w, int p_parent_h); void VisualServerRaster::_draw_viewports(); void VisualServerRaster::_draw_cursors_and_margins(); void VisualServerRaster::sync(); void VisualServerRaster::draw(); bool VisualServerRaster::has_changed(); int VisualServerRaster::get_render_info(RenderInfo p_info); bool VisualServerRaster::has_feature(Features p_feature); void VisualServerRaster::set_default_clear_color(const Color &p_color); Color VisualServerRaster::get_default_clear_color(); void VisualServerRaster::set_time_scale(float p_scale); void VisualServerRaster::set_boot_image(const Image &p_image, const Color &p_color, bool p_scale); void VisualServerRaster::init(); void VisualServerRaster::_clean_up_owner(RID_OwnerBase *p_owner, String p_type); void VisualServerRaster::finish(); RID VisualServerRaster::get_test_cube(); VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer); VisualServerRaster::~VisualServerRaster();

6545c274d355c027e2e8f9289f588bc7fa06582af2a3c8cc78faa8da9fd78e0c

opticode

pyviennacl-dev

src/_viennacl/platform_support.cpp

get_opencl_handle

vcl::vcl_size_t get_opencl_handle(vcl::backend::mem_handle& m) { return (vcl::vcl_size_t) m.opencl_handle().get(); }

vcl::vcl_size_t get_ram_handle(vcl::backend::mem_handle& m); void set_ram_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr); void set_opencl_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr); const vcl::ocl::context& get_opencl_handle_context(vcl::backend::mem_handle& m); vcl::vcl_size_t get_cuda_handle(vcl::backend::mem_handle& m); void set_cuda_handle(vcl::backend::mem_handle& m, vcl::vcl_size_t ptr); PYVCL_SUBMODULE(platform_support);

afab933ad2ae064f79a1bf63d9987c8d262ff16cdcd9afc5def31fd4a4964bd1

MatejGomboc

Neural-Networks

neural_networks/neural_networks_code/src/population.cpp

Mutation_params::get_prob_mut_neuron_steepness

double Mutation_params::get_prob_mut_neuron_steepness(void) const { return m_dProb_mut_neuron_steepness; }

double Mutation_params::get_prob_mut_neuron_weight(void); double Mutation_params::get_prob_mut_output_weight(void); double Mutation_params::get_prob_mut_neuron_treshold(void); double Mutation_params::get_prob_mut_neuron_simetricity(void); void Mutation_params::set_prob_mut_neuron_weight(double probability); void Mutation_params::set_prob_mut_output_weight(double probability); void Mutation_params::set_prob_mut_neuron_treshold(double probability); void Mutation_params::set_prob_mut_neuron_steepness(double probability); void Mutation_params::set_prob_mut_neuron_simetricity(double probability); Population::Population(std::vector<std::shared_ptr<Member>>& p_members); Population::~Population(void); void Population::check_members(void); void Population::calculate_outputs(void); double Population::mutate_value(const double probability, const double min_value, const double max_value, ); void Population::mutate(void); void Population::mate(void); unsigned long Population::roulette_wheel(void); unsigned long Population::roulette_wheel(const unsigned long dropped_memb_indx); unsigned long Population::roulette_wheel(const std::set<const unsigned long>& dropped_memb_indices);

5919ed065c768c5e5ad952dc466daa35320bf7867b679d190d3661868522fa1c

cutelyst

grantlee

templates/defaulttags/mediafinder.cpp

MediaFinderNodeFactory::getNode

Grantlee::Node* MediaFinderNodeFactory::getNode( const QString& tagContent, Parser* p ) const { QStringList expr = smartSplit( tagContent ); if ( expr.size() <= 1 ) { throw Grantlee::Exception( TagSyntaxError, QStringLiteral( "'media_finder' tag requires at least one argument" ) ); } expr.takeAt( 0 ); return new MediaFinderNode( getFilterExpressionList( expr, p ), p ); }

MediaFinderNodeFactory::MediaFinderNodeFactory(); MediaFinderNode::MediaFinderNode( QList<FilterExpression> mediaExpressionList, QObject* parent ); void MediaFinderNode::render( OutputStream *stream, Context* c );

a3308c333bd8d0f2fccee3c0dc73352ee0c56a67b5650458aa9817c67c37d88c

kevL

0xC_kL

src/Ruleset/Ruleset.cpp

Ruleset::getAlienMission

const RuleAlienMission* Ruleset::getAlienMission(const std::string& type) const { std::map<std::string, RuleAlienMission*>::const_iterator i (_alienMissions.find(type)); if (i != _alienMissions.end()) return i->second; return nullptr; }

Ruleset::Ruleset(const Game* const game); Ruleset::~Ruleset(); void Ruleset::reloadCountryLines(); void Ruleset::validateMissions(); void Ruleset::load(const std::string& src); void Ruleset::loadFiles(const std::string& dir); void Ruleset::loadFile(const std::string& file); SavedGame* Ruleset::createSave(Game* const play); const std::vector<OperationPool*>& Ruleset::getOperations(); RuleCountry* Ruleset::getCountry(const std::string& id); const std::vector<std::string>& Ruleset::getCountriesList(); RuleRegion* Ruleset::getRegion(const std::string& id); const std::vector<std::string>& Ruleset::getRegionsList(); RuleBaseFacility* Ruleset::getBaseFacility(const std::string& id); const std::vector<std::string>& Ruleset::getBaseFacilitiesList(); RuleCraft* Ruleset::getCraft(const std::string& id); const std::vector<std::string>& Ruleset::getCraftsList(); RuleCraftWeapon* Ruleset::getCraftWeapon(const std::string& id); const std::vector<std::string>& Ruleset::getCraftWeaponsList(); RuleItem* Ruleset::getItemRule(const std::string& id); const std::vector<std::string>& Ruleset::getItemsList(); RuleUfo* Ruleset::getUfo(const std::string& id); const std::vector<std::string>& Ruleset::getUfosList(); RuleTerrain* Ruleset::getTerrain(const std::string& type); const std::vector<std::string>& Ruleset::getTerrainList(); MapDataSet* Ruleset::getMapDataSet(const std::string& type); const std::map<std::string, const RuleAward*>& Ruleset::getAwardsList(); RuleSoldier* Ruleset::getSoldier(const std::string& type); const std::vector<std::string>& Ruleset::getSoldiersList(); RuleUnit* Ruleset::getUnitRule(const std::string& type); RuleAlienRace* Ruleset::getAlienRace(const std::string& type); const std::vector<std::string>& Ruleset::getAlienRacesList(); RuleAlienDeployment* Ruleset::getDeployment(const std::string& type); const std::vector<std::string>& Ruleset::getDeploymentsList(); RuleArmor* Ruleset::getArmor(const std::string& type); const std::vector<std::string>& Ruleset::getArmorsList(); int Ruleset::getEngineerCost(); int Ruleset::getScientistCost(); int Ruleset::getPersonnelTime(); ArticleDefinition* Ruleset::getUfopaediaArticle(const std::string& article_id); const std::vector<std::string>& Ruleset::getUfopaediaList(); std::map<std::string, RuleInventory*>* Ruleset::getInventories(); const RuleInventory* Ruleset::getInventory(const std::string& type); const RuleInventory* Ruleset::getInventoryRule(InventorySection sectionId); void Ruleset::convertInventories(); int Ruleset::getHighestDropCost(); const RuleResearch* Ruleset::getResearch(const std::string& type); const std::vector<std::string>& Ruleset::getResearchList(); RuleManufacture* Ruleset::getManufacture(const std::string& type); const std::vector<std::string>& Ruleset::getManufactureList(); std::vector<RuleBaseFacility*> Ruleset::getStartFacilities(); const UfoTrajectory* Ruleset::getUfoTrajectory(const std::string& type); const std::vector<std::string>& Ruleset::getAlienMissionList(); const std::vector<std::vector<int>>& Ruleset::getAlienItemLevels(); const YAML::Node& Ruleset::getStartBase(); MCDPatch* Ruleset::getMCDPatch(const std::string& type); std::vector<std::pair<std::string, RuleMusic*>> Ruleset::getMusicTracks(); std::vector<std::pair<std::string, ExtraSprites*>> Ruleset::getExtraSprites(); std::vector<std::pair<std::string, ExtraSounds*>> Ruleset::getExtraSounds(); std::map<std::string, ExtraStrings*> Ruleset::getExtraStrings(); bool operator(); CompareRule(Ruleset* ruleset); bool operator(); CompareRule(Ruleset* const ruleset); bool operator(); bool operator(); void Ruleset::sortLists(); const std::string& Ruleset::getAlienFuelType(); int Ruleset::getAlienFuelQuantity(); std::string Ruleset::getFontName(); int Ruleset::getRadarRangeBest(); int Ruleset::getRadarRangeCutoff(); int Ruleset::getFirstGrenade(); int Ruleset::getRetaliation(); RuleInterface* Ruleset::getInterface(const std::string& id); RuleGlobe* Ruleset::getGlobe(); const std::map<std::string, RuleVideo*>* Ruleset::getVideos(); const std::vector<std::string>* Ruleset::getMissionScriptList(); RuleMissionScript* Ruleset::getMissionScript(const std::string& type); const std::vector<RuleMapScript*>* Ruleset::getMapScripts(const std::string& type); const std::string& Ruleset::getFinalResearch(); int Ruleset::getDefeatFunds(); int Ruleset::getDefeatScore(); int Ruleset::getBaseLostScore(); const Game* Ruleset::getGame();

72882da10abc4cec3bc99f9a93a2022dddf234cf26cf2ce96a53d731231e8e6e

01org

vmf

3rdparty/cryptopp/basecode.cpp

BaseN_Decoder::Put2

size_t BaseN_Decoder::Put2(const byte *begin, size_t length, int messageEnd, bool blocking) { FILTER_BEGIN; while (m_inputPosition < length) { unsigned int value; value = m_lookup[begin[m_inputPosition++]]; if (value >= 256) continue; if (m_bytePos == 0 && m_bitPos == 0) memset(m_outBuf, 0, m_outputBlockSize); { int newBitPos = m_bitPos + m_bitsPerChar; if (newBitPos <= 8) m_outBuf[m_bytePos] |= value << (8-newBitPos); else { m_outBuf[m_bytePos] |= value >> (newBitPos-8); m_outBuf[m_bytePos+1] |= value << (16-newBitPos); } m_bitPos = newBitPos; while (m_bitPos >= 8) { m_bitPos -= 8; ++m_bytePos; } } if (m_bytePos == m_outputBlockSize) { FILTER_OUTPUT(1, m_outBuf, m_outputBlockSize, 0); m_bytePos = m_bitPos = 0; } } if (messageEnd) { FILTER_OUTPUT(2, m_outBuf, m_bytePos, messageEnd); m_bytePos = m_bitPos = 0; } FILTER_END_NO_MESSAGE_END; }

void BaseN_Encoder::IsolatedInitialize(const NameValuePairs &parameters); size_t BaseN_Encoder::Put2(const byte *begin, size_t length, int messageEnd, bool blocking); void BaseN_Decoder::IsolatedInitialize(const NameValuePairs &parameters); void BaseN_Decoder::InitializeDecodingLookupArray(int *lookup, const byte *alphabet, unsigned int base, bool caseInsensitive); void Grouper::IsolatedInitialize(const NameValuePairs &parameters); size_t Grouper::Put2(const byte *begin, size_t length, int messageEnd, bool blocking);

54506f42e43a373f3c78806887c77605f222dacd99e127595879aeff11e3c2c2

Bloodknight

Torque3D

Engine/lib/assimp/code/AssetLib/Terragen/TerragenLoader.cpp

TerragenImporter::InternReadFile

void TerragenImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { IOStream *file = pIOHandler->Open(pFile, "rb"); if (file == nullptr) throw DeadlyImportError("Failed to open TERRAGEN TERRAIN file ", pFile, "."); StreamReaderLE reader(file); if (reader.GetRemainingSize() < 16) throw DeadlyImportError("TER: file is too small"); if (::strncmp((const char *)reader.GetPtr(), AI_TERR_BASE_STRING, 8)) throw DeadlyImportError("TER: Magic string \'TERRAGEN\' not found"); if (::strncmp((const char *)reader.GetPtr() + 8, AI_TERR_TERRAIN_STRING, 8)) throw DeadlyImportError("TER: Magic string \'TERRAIN\' not found"); unsigned int x = 0, y = 0, mode = 0; aiNode *root = pScene->mRootNode = new aiNode(); root->mName.Set("<TERRAGEN.TERRAIN>"); root->mTransformation.a1 = root->mTransformation.b2 = root->mTransformation.c3 = 30.f; reader.IncPtr(16); while (reader.GetRemainingSize() >= 4) { const char *head = (const char *)reader.GetPtr(); reader.IncPtr(4); if (!::strncmp(head, AI_TERR_EOF_STRING, 4)) break; if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) { x = (uint16_t)reader.GetI2(); } else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) { y = (uint16_t)reader.GetI2(); } else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) { x = y = (uint16_t)reader.GetI2() + 1; } else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) { root->mTransformation.a1 = reader.GetF4(); root->mTransformation.b2 = reader.GetF4(); root->mTransformation.c3 = reader.GetF4(); } else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) { reader.GetF4(); } else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) { mode = reader.GetI1(); if (0 != mode) ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned"); } else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) { float hscale = (float)reader.GetI2() / 65536; float bheight = (float)reader.GetI2(); if (!hscale) hscale = 1; if (reader.GetRemainingSize() < x * y * 2) throw DeadlyImportError("TER: ALTW chunk is too small"); if (x <= 1 || y <= 1) throw DeadlyImportError("TER: Invalid terrain size"); pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = 1]; aiMesh *m = pScene->mMeshes[0] = new aiMesh(); aiFace *f = m->mFaces = new aiFace[m->mNumFaces = (x - 1) * (y - 1)]; aiVector3D *pv = m->mVertices = new aiVector3D[m->mNumVertices = m->mNumFaces * 4]; aiVector3D *uv(nullptr); float step_y(0.0f), step_x(0.0f); if (configComputeUVs) { uv = m->mTextureCoords[0] = new aiVector3D[m->mNumVertices]; step_y = 1.f / y; step_x = 1.f / x; } const int16_t *data = (const int16_t *)reader.GetPtr(); for (unsigned int yy = 0, t = 0; yy < y - 1; ++yy) { for (unsigned int xx = 0; xx < x - 1; ++xx, ++f) { const float fy = (float)yy, fx = (float)xx; unsigned tmp, tmp2; *pv++ = aiVector3D(fx, fy, (float)data[(tmp2 = x * yy) + xx] * hscale + bheight); *pv++ = aiVector3D(fx, fy + 1, (float)data[(tmp = x * (yy + 1)) + xx] * hscale + bheight); *pv++ = aiVector3D(fx + 1, fy + 1, (float)data[tmp + xx + 1] * hscale + bheight); *pv++ = aiVector3D(fx + 1, fy, (float)data[tmp2 + xx + 1] * hscale + bheight); if (configComputeUVs) { *uv++ = aiVector3D(step_x * xx, step_y * yy, 0.f); *uv++ = aiVector3D(step_x * xx, step_y * (yy + 1), 0.f); *uv++ = aiVector3D(step_x * (xx + 1), step_y * (yy + 1), 0.f); *uv++ = aiVector3D(step_x * (xx + 1), step_y * yy, 0.f); } f->mIndices = new unsigned int[f->mNumIndices = 4]; for (unsigned int i = 0; i < 4; ++i) { f->mIndices[i] = t; t++; } } } root->mMeshes = new unsigned int[root->mNumMeshes = 1]; root->mMeshes[0] = 0; } unsigned dtt = reader.GetCurrentPos(); if (dtt & 0x3) { reader.IncPtr(4 - dtt); } } if (pScene->mNumMeshes != 1) throw DeadlyImportError("TER: Unable to load terrain"); pScene->mFlags |= AI_SCENE_FLAGS_TERRAIN; }

TerragenImporter::TerragenImporter(); TerragenImporter::~TerragenImporter(); bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/); const aiImporterDesc *TerragenImporter::GetInfo(); void TerragenImporter::SetupProperties(const Importer *pImp);

99d2c6543c94d4fb9d6b66c79cf7f62c185d4ef5f6d07897ae705ffdb936221b

digama0

lean

src/library/tactic/rewrite_tactic.cpp

rewrite_cfg::rewrite_cfg

rewrite_cfg::rewrite_cfg(vm_obj const & cfg):apply_cfg(cfield(cfg, 0)) { m_symm = to_bool(cfield(cfg, 1)); m_occs = to_occurrences(cfield(cfg, 2)); }

static vm_obj rewrite_core(expr h, expr e, rewrite_cfg const & cfg, tactic_state s); vm_obj tactic_rewrite_core(vm_obj const & h, vm_obj const & e, vm_obj const & cfg, vm_obj const & s); void initialize_rewrite_tactic(); void finalize_rewrite_tactic();

89b1d30ea858db867f7ccdbe4ae29781092e8c7078ff6476a2ed4202f649ca2a

TheCoSMoCompany

biopredyn

Prototype/src/libsbml-5.10.0/src/sbml/math/ASTCnExponentialNode.cpp

ASTCnExponentialNode::ASTCnExponentialNode

ASTCnExponentialNode::ASTCnExponentialNode (const ASTCnExponentialNode& orig): ASTCnBase(orig) , mExponent (orig.mExponent) , mMantissa (orig.mMantissa) , mIsSetMantissa (orig.mIsSetMantissa) , mIsSetExponent (orig.mIsSetExponent) { }

ASTCnExponentialNode::~ASTCnExponentialNode ();

1c24e9c567e4ebdf3d7b50a00c300dcd7553241dd785663e28a340fbad905ba1

Ruscris2

RC-Engine

RC-Engine/RenderDummy.cpp

RenderDummy::Render

void RenderDummy::Render(VulkanInterface * vulkan, VulkanCommandBuffer * commandBuffer, VulkanPipeline * vulkanPipeline, glm::mat4 orthoMatrix, Sunlight * light, int imageIndex, Camera * camera, ShadowMaps * shadowMaps, int frameBufferId) { vertexUniformBuffer.MVP = orthoMatrix; vsUBO->Update(vulkan->GetVulkanDevice(), &vertexUniformBuffer, sizeof(vertexUniformBuffer)); fragmentUniformBuffer.lightDirection = light->GetLightDirection(); fragmentUniformBuffer.imageIndex = imageIndex; fragmentUniformBuffer.cameraPosition = camera->GetPosition(); fragmentUniformBuffer.lightStrength = light->GetLightStrength(); for (int i = 0; i < SHADOW_CASCADE_COUNT; i++) fragmentUniformBuffer.lightViewMatrix[i] = shadowMaps->GetLightViewProj(i); fsUBO->Update(vulkan->GetVulkanDevice(), &fragmentUniformBuffer, sizeof(fragmentUniformBuffer)); drawCmdBuffers[frameBufferId]->BeginRecordingSecondary(vulkan->GetForwardRenderpass()->GetRenderpass(), vulkan->GetVulkanSwapchain()->GetFramebuffer((int)frameBufferId)); vulkan->InitViewportAndScissors(drawCmdBuffers[frameBufferId], (float)gSettings->GetWindowWidth(), (float)gSettings->GetWindowHeight(), (uint32_t)gSettings->GetWindowWidth(), (uint32_t)gSettings->GetWindowHeight()); vulkanPipeline->SetActive(drawCmdBuffers[frameBufferId]); VkDeviceSize offsets[1] = { 0 }; vkCmdBindVertexBuffers(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), 0, 1, vertexBuffer->GetBuffer(), offsets); vkCmdBindIndexBuffer(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), *indexBuffer->GetBuffer(), 0, VK_INDEX_TYPE_UINT32); vkCmdDrawIndexed(drawCmdBuffers[frameBufferId]->GetCommandBuffer(), indexCount, 1, 0, 0, 0); drawCmdBuffers[frameBufferId]->EndRecording(); drawCmdBuffers[frameBufferId]->ExecuteSecondary(commandBuffer); }

RenderDummy::RenderDummy(); RenderDummy::~RenderDummy(); void RenderDummy::Unload(VulkanInterface * vulkan);

d6d8e96c9036c415eecd2f07bc5d7333da8401f7b1a7f4fcbc2d2097ab49a43c